Removal of SmartGraphEdgeBase interface. No longer needed as we now have a single generic SmartGraphEdgeNode implementation.

Author: brunomnsilva

src/main/java/com/brunomnsilva/smartgraph/graphview/SmartGraphEdge.java

@@ -50,7 +50,19 @@ public interface SmartGraphEdge<E, V> extends SmartStylableNode {
      * @see SmartGraphPanel
      */
     Edge<E, V> getUnderlyingEdge();
-    
+
+    /**
+     * Returns the inbound vertex of the edge.
+     * @return the inbound vertex of the edge.
+     */
+    SmartGraphVertex<V> getInbound();
+
+    /**
+     * Returns the outbound vertex of the edge.
+     * @return the outbound vertex of the edge.
+     */
+    SmartGraphVertex<V> getOutbound();
+
     /**
      * Returns the attached arrow of the edge, for styling purposes.
      * <br/>

src/main/java/com/brunomnsilva/smartgraph/graphview/SmartGraphEdgeBase.java

@@ -52,7 +52,7 @@
  *
  * @author brunomnsilva
  */
-public class SmartGraphEdgeNode<E, V> extends CubicCurve implements SmartGraphEdgeBase<E, V> {
+public class SmartGraphEdgeNode<E, V> extends CubicCurve implements SmartGraphEdge<E, V>, SmartLabelledNode {
 
     // For self-loops
     public static final int LOOP_RADIUS_FACTOR = 4;
@@ -140,12 +140,18 @@ public SmartGraphEdgeNode(Edge<E, V> edge, SmartGraphVertexNode<V> inbound, Smar
         propagateHoverEffectToArrow();
     }
 
-    @Override
+    /**
+     * Returns the current multiplicity index of the edge.
+     * @return the current multiplicity index of the edge.
+     */
     public int getMultiplicityIndex() {
         return multiplicityIndex;
     }
 
-    @Override
+    /**
+     * Sets the multiplicity index of the edge. This impacts the curve of the edge.
+     * @param multiplicityIndex the new multiplicity index.
+     */
     public void setMultiplicityIndex(int multiplicityIndex) {
         Args.requireNonNegative(multiplicityIndex, "multiplicityIndex");
 
@@ -156,12 +162,12 @@ public void setMultiplicityIndex(int multiplicityIndex) {
     }
 
     @Override
-    public SmartGraphVertexNode<V> getInbound() {
+    public SmartGraphVertex<V> getInbound() {
         return inbound;
     }
 
     @Override
-    public SmartGraphVertexNode<V> getOutbound() {
+    public SmartGraphVertex<V> getOutbound() {
         return outbound;
     }
 
@@ -406,7 +412,11 @@ public Edge<E, V> getUnderlyingEdge() {
         return underlyingEdge;
     }
 
-    @Override
+    /**
+     * Attaches a {@link SmartArrow} to this edge, binding its position/rotation.
+     *
+     * @param arrow     arrow to attach
+     */
     public void attachArrow(SmartArrow arrow) {
         this.attachedArrow = arrow;
 
@@ -437,7 +447,11 @@ public void attachArrow(SmartArrow arrow) {
         arrow.getTransforms().add(pullbackTranslation);
     }
 
-    @Override
+    /**
+     * Returns the attached {@link SmartArrow}, if any.
+     *
+     * @return      reference of the attached arrow; null if none.
+     */
     public SmartArrow getAttachedArrow() {
         return this.attachedArrow;
     }

src/main/java/com/brunomnsilva/smartgraph/graphview/SmartGraphEdgeNode.java

@@ -90,7 +90,7 @@ public class SmartGraphPanel<V, E> extends Pane {
     private final Graph<V, E> theGraph;
     private final SmartPlacementStrategy placementStrategy;
     private final Map<Vertex<V>, SmartGraphVertexNode<V>> vertexNodes;
-    private final Map<Edge<E, V>, SmartGraphEdgeBase<E, V>> edgeNodes;
+    private final Map<Edge<E, V>, SmartGraphEdgeNode<E, V>> edgeNodes;
     private final Map<Edge<E,V>, Tuple<Vertex<V>>> connections;
     private boolean initialized = false;
     private final boolean edgesWithArrows;
@@ -631,7 +631,7 @@ private void initNodes() {
                 graphVertexIn.addAdjacentVertex(graphVertexOppositeOut);
                 graphVertexOppositeOut.addAdjacentVertex(graphVertexIn);
 
-                SmartGraphEdgeBase<E,V> graphEdge = createEdge(edge, graphVertexIn, graphVertexOppositeOut);
+                SmartGraphEdgeNode<E,V> graphEdge = createEdge(edge, graphVertexIn, graphVertexOppositeOut);
 
                 /* Track Edges already placed */
                 connections.put(edge, new Tuple<>(vertex, oppositeVertex));
@@ -660,7 +660,7 @@ private SmartGraphVertexNode<V> createVertex(Vertex<V> v, double x, double y) {
         return new SmartGraphVertexNode<>(this, v, x, y, shapeRadius, shapeType, graphProperties.getVertexAllowUserMove());
     }
 
-    private SmartGraphEdgeBase<E,V> createEdge(Edge<E, V> edge, SmartGraphVertexNode<V> graphVertexInbound, SmartGraphVertexNode<V> graphVertexOutbound) {
+    private SmartGraphEdgeNode<E,V> createEdge(Edge<E, V> edge, SmartGraphVertexNode<V> graphVertexInbound, SmartGraphVertexNode<V> graphVertexOutbound) {
         /*
          Edges will be placed with 'multiplicityIndex' starting at 0 for a single edge between a pair of vertices. This represents a straight edge.
          When more than an edge exists, the 'multiplicityIndex' will start at 1, forcing the edges to be curved.
@@ -695,16 +695,16 @@ private void addVertex(SmartGraphVertexNode<V> v) {
         }
     }
 
-    private void addEdge(SmartGraphEdgeBase<E,V> e, Edge<E, V> edge) {
+    private void addEdge(SmartGraphEdgeNode<E,V> e, Edge<E, V> edge) {
         // Edges to the back
-        this.getChildren().add(0, (Node) e);
+        this.getChildren().add(0, e);
         edgeNodes.put(edge, e);
 
         String labelText = getEdgeLabelFor(edge.element());
 
         if (graphProperties.getUseEdgeTooltip()) {
             Tooltip t = new Tooltip(labelText);
-            Tooltip.install((Node) e, t);
+            Tooltip.install(e, t);
         }
 
         if (graphProperties.getUseEdgeLabel()) {
@@ -804,7 +804,7 @@ The opposite vertex exists in the (di)graph, but we have not yet
                 graphVertexOut.addAdjacentVertex(graphVertexIn);
                 graphVertexIn.addAdjacentVertex(graphVertexOut);
 
-                SmartGraphEdgeBase<E,V> graphEdge = createEdge(edge, graphVertexIn, graphVertexOut);
+                SmartGraphEdgeNode<E,V> graphEdge = createEdge(edge, graphVertexIn, graphVertexOut);
 
                  /* Track edges */
                 connections.put(edge, new Tuple<>(u, v));
@@ -825,7 +825,7 @@ private void removeNodes() {
          //remove edges (graphical elements) that were removed from the underlying graph
         Collection<Edge<E, V>> removedEdges = removedEdges();
         for (Edge<E, V> e : removedEdges) {
-            SmartGraphEdgeBase<E,V> edgeToRemove = edgeNodes.get(e);
+            SmartGraphEdgeNode<E,V> edgeToRemove = edgeNodes.get(e);
             edgeNodes.remove(e);
             removeEdge(edgeToRemove);   //remove from panel
 
@@ -856,8 +856,8 @@ private void removeNodes() {
 
     }
 
-    private void removeEdge(SmartGraphEdgeBase<E,V> e) {
-        getChildren().remove((Node) e);
+    private void removeEdge(SmartGraphEdgeNode<E,V> e) {
+        getChildren().remove(e);
 
         SmartArrow attachedArrow = e.getAttachedArrow();
         if (attachedArrow != null) {
@@ -878,13 +878,13 @@ private void removeEdge(SmartGraphEdgeBase<E,V> e) {
      *
      * This work
      */
-    private void updateParallelEdgesOf(SmartGraphEdgeBase<E,V> e) {
+    private void updateParallelEdgesOf(SmartGraphEdgeNode<E,V> e) {
 
-        SmartGraphVertexNode<V> v = e.getInbound();
-        SmartGraphVertexNode<V> w = e.getOutbound();
+        SmartGraphVertexNode<V> v = (SmartGraphVertexNode<V>)e.getInbound();
+        SmartGraphVertexNode<V> w = (SmartGraphVertexNode<V>)e.getOutbound();
 
         // 'getEdgesBetween' returns a collection of ages, ordered by their "age".
-        List<SmartGraphEdgeBase<E, V>> parallelEdges = getEdgesBetween(v, w);
+        List<SmartGraphEdgeNode<E, V>> parallelEdges = getEdgesBetween(v, w);
 
         int numEdges = parallelEdges.size();
         if(numEdges > 0) {
@@ -941,7 +941,7 @@ private void updateNodes() {
         });
 
         theGraph.edges().forEach((e) -> {
-            SmartGraphEdgeBase<E,V> edgeNode = edgeNodes.get(e);
+            SmartGraphEdgeNode<E,V> edgeNode = edgeNodes.get(e);
             if (edgeNode != null) {
                 SmartLabel label = edgeNode.getAttachedLabel();
                 if (label != null) {
@@ -1048,7 +1048,7 @@ protected final double getVertexShapeRadiusFor(V vertexElement) {
         return graphProperties.getVertexRadius();
     }
 
-    /*protected final List<SmartGraphEdgeBase> getConnectedEdgesFor(SmartGraphVertexNode<V> node) {
+    /*protected final List<SmartGraphEdgeNode> getConnectedEdgesFor(SmartGraphVertexNode<V> node) {
         if(node == null) throw new IllegalArgumentException("node cannot be null."); // defensive
 
         Vertex<V> underlyingVertex = node.getUnderlyingVertex();
@@ -1063,7 +1063,7 @@ protected final double getVertexShapeRadiusFor(V vertexElement) {
         }
 
         // Get the corresponding smart edges
-        List<SmartGraphEdgeBase> connected = new ArrayList<>();
+        List<SmartGraphEdgeNode> connected = new ArrayList<>();
 
         for (Edge<E, V> edge : edges) {
             connected.add ( edgeNodes.get(edge) );
@@ -1135,11 +1135,11 @@ private int getTotalEdgesBetweenInModel(Vertex<V> v, Vertex<V> u) {
      * @param u second vertex
      * @return an ordered (by age) list of edges that exist between 'u' and 'v'
      */
-    private List<SmartGraphEdgeBase<E, V>> getEdgesBetween(SmartGraphVertexNode<V> v, SmartGraphVertexNode<V> u) {
+    private List<SmartGraphEdgeNode<E, V>> getEdgesBetween(SmartGraphVertexNode<V> v, SmartGraphVertexNode<V> u) {
         Vertex<V> V = v.getUnderlyingVertex();
         Vertex<V> U = u.getUnderlyingVertex();
 
-        List<SmartGraphEdgeBase<E, V>> parallelEdges = new ArrayList<>();
+        List<SmartGraphEdgeNode<E, V>> parallelEdges = new ArrayList<>();
 
         for (Map.Entry<Edge<E, V>, Tuple<Vertex<V>>> edgeTupleEntry : this.connections.entrySet()) {
             Edge<E, V> edge = edgeTupleEntry.getKey();
@@ -1162,9 +1162,9 @@ private List<SmartGraphEdgeBase<E, V>> getEdgesBetween(SmartGraphVertexNode<V> v
      */
     private int getMaxMultiplicityIndexBetween(SmartGraphVertexNode<V> v, SmartGraphVertexNode<V> u) {
         int max = -1;
-        for (SmartGraphEdgeBase<E, V> edge : edgeNodes.values()) {
-            SmartGraphVertexNode<V> in = edge.getInbound();
-            SmartGraphVertexNode<V> out = edge.getOutbound();
+        for (SmartGraphEdgeNode<E, V> edge : edgeNodes.values()) {
+            SmartGraphVertexNode<V> in = (SmartGraphVertexNode<V>)edge.getInbound();
+            SmartGraphVertexNode<V> out = (SmartGraphVertexNode<V>)edge.getOutbound();
 
             if(in == v && out == u || in == u && out == v) {
                 int cur = edge.getMultiplicityIndex();
@@ -1233,9 +1233,9 @@ private Collection<Edge<E, V>> removedEdges() {
         List<Edge<E, V>> removed = new LinkedList<>();
 
         Collection<Edge<E, V>> graphEdges = theGraph.edges();
-        Collection<SmartGraphEdgeBase<E,V>> plotted = edgeNodes.values();
+        Collection<SmartGraphEdgeNode<E,V>> plotted = edgeNodes.values();
 
-        for (SmartGraphEdgeBase<E,V> e : plotted) {
+        for (SmartGraphEdgeNode<E,V> e : plotted) {
             if (!graphEdges.contains(e.getUnderlyingEdge())) {
                 removed.add(e.getUnderlyingEdge());
             }
@@ -1376,7 +1376,7 @@ public SmartStylableNode getStylableLabel(Vertex<V> v) {
      * @return stylable element (label)
      */
     public SmartStylableNode getStylableLabel(Edge<E,V> e) {
-        SmartGraphEdgeBase<E,V> edge = edgeNodes.get(e);
+        SmartGraphEdgeNode<E,V> edge = edgeNodes.get(e);
 
         return edge != null ? edge.getStylableLabel() : null;
     }