Refactored Node list to a Collection in edges.

src/main/java/com/syncleus/dann/graph/AbstractDirectedEdge.java

@@ -18,6 +18,7 @@
  ******************************************************************************/
 package com.syncleus.dann.graph;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -48,7 +49,7 @@ public abstract class AbstractDirectedEdge<N> extends AbstractBidirectedEdge<N>
 	}
 
 	@Override
-	public List<N> getTraversableNodes(final N node)
+	public Collection<N> getTraversableNodes(final N node)
 	{
 		if( this.getSourceNode().equals(node) )
 			return Collections.singletonList(this.getDestinationNode());

src/main/java/com/syncleus/dann/graph/AbstractHyperEdge.java

@@ -19,6 +19,7 @@
 package com.syncleus.dann.graph;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -26,7 +27,7 @@ public abstract class AbstractHyperEdge<N> extends AbstractTraversableCloud<N> i
 {
 	private static final long serialVersionUID = -3657973823101515199L;
 
-	protected AbstractHyperEdge(final List<N> nodes)
+	protected AbstractHyperEdge(final Collection<N> nodes)
 	{
 		super(nodes);
 	}
@@ -36,7 +37,7 @@ public abstract class AbstractHyperEdge<N> extends AbstractTraversableCloud<N> i
 		super(nodes);
 	}
 
-	protected AbstractHyperEdge(final List<N> nodes, final boolean allowJoiningMultipleGraphs, final boolean contextEnabled)
+	protected AbstractHyperEdge(final Collection<N> nodes, final boolean allowJoiningMultipleGraphs, final boolean contextEnabled)
 	{
 		super(nodes, allowJoiningMultipleGraphs, contextEnabled);
 	}
@@ -47,7 +48,7 @@ public abstract class AbstractHyperEdge<N> extends AbstractTraversableCloud<N> i
 	}
 
 	@Override
-	public List<N> getTraversableNodes(final N node)
+	public Collection<N> getTraversableNodes(final N node)
 	{
 		final List<N> traversableNodes = new ArrayList<N>(this.getNodes());
 		if( !traversableNodes.remove(node) )

src/main/java/com/syncleus/dann/graph/AbstractTraversableCloud.java

@@ -18,12 +18,8 @@
  ******************************************************************************/
 package com.syncleus.dann.graph;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+
 import com.syncleus.dann.UnexpectedDannError;
 import com.syncleus.dann.graph.context.AbstractContextGraphElement;
 import com.syncleus.dann.graph.context.ContextNode;
@@ -52,12 +48,12 @@ public abstract class AbstractTraversableCloud<N> extends AbstractContextGraphEl
 		this.contextEnabled = contextEnabled;
 	}
 
-	protected AbstractTraversableCloud(final List<N> ourNodes)
+	protected AbstractTraversableCloud(final Collection<N> ourNodes)
 	{
 		this(ourNodes, true, true);
 	}
 
-	protected AbstractTraversableCloud(final List<N> ourNodes, final boolean allowJoiningMultipleGraphs, final boolean contextEnabled)
+	protected AbstractTraversableCloud(final Collection<N> ourNodes, final boolean allowJoiningMultipleGraphs, final boolean contextEnabled)
 	{
 		super(allowJoiningMultipleGraphs);
 		this.contextEnabled = contextEnabled;
@@ -176,7 +172,7 @@ public abstract class AbstractTraversableCloud<N> extends AbstractContextGraphEl
 	}
 
 	@Override
-	public final List<N> getNodes()
+	public final Collection<N> getNodes()
 	{
 		return this.nodes;
 	}

src/main/java/com/syncleus/dann/graph/AbstractUndirectedEdge.java

@@ -18,6 +18,7 @@
  ******************************************************************************/
 package com.syncleus.dann.graph;
 
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -36,7 +37,7 @@ public abstract class AbstractUndirectedEdge<N> extends AbstractBidirectedEdge<N
 	}
 
 	@Override
-	public List<N> getTraversableNodes(final N node)
+	public Collection<N> getTraversableNodes(final N node)
 	{
 		if( this.getLeftNode().equals(node) )
 			return Collections.singletonList(this.getRightNode());

src/main/java/com/syncleus/dann/graph/Cloud.java

@@ -23,10 +23,11 @@ import com.syncleus.dann.graph.xml.EdgeXml;
 import com.syncleus.dann.xml.XmlSerializable;
 
 import java.io.Serializable;
+import java.util.Collection;
 import java.util.List;
 
 public interface Cloud<N> extends Serializable, Cloneable, XmlSerializable<EdgeXml, Object>, ContextReporter
 {
-    List<N> getNodes();
-    List<N> getTraversableNodes(N node);
+    Collection<N> getNodes();
+    Collection<N> getTraversableNodes(N node);
 }

src/main/java/com/syncleus/dann/graph/ImmutableHyperEdge.java

@@ -18,13 +18,14 @@
  ******************************************************************************/
 package com.syncleus.dann.graph;
 
+import java.util.Collection;
 import java.util.List;
 
 public final class ImmutableHyperEdge<N> extends AbstractHyperEdge<N>
 {
 	private static final long serialVersionUID = -3657973823101515199L;
 
-	public ImmutableHyperEdge(final List<N> nodes)
+	public ImmutableHyperEdge(final Collection<N> nodes)
 	{
 		super(nodes);
 	}

src/main/java/com/syncleus/dann/graph/SimpleCycle.java

@@ -46,14 +46,14 @@ public class SimpleCycle<N, E extends TraversableCloud<N>> extends SimpleWalk<N,
 	private static <N, E extends TraversableCloud<N>> N startNodeFromSteps(final List<E> steps)
 	{
 		if( steps.size() == 1 )
-			return steps.get(0).getNodes().get(0);
+			return steps.get(0).getNodes().iterator().next();
 
 		final List<N> exclusiveFirstNodes = new ArrayList<N>(steps.get(0).getNodes());
 		exclusiveFirstNodes.removeAll(steps.get(1).getNodes());
 		if( exclusiveFirstNodes.size() == 1 )
 			return exclusiveFirstNodes.get(0);
 		else if( exclusiveFirstNodes.isEmpty() )
-			return steps.get(0).getNodes().get(0);
+			return steps.get(0).getNodes().iterator().next();
 		else
 			throw new IllegalArgumentException("steps does not form a path");
 	}

src/main/java/com/syncleus/dann/graph/topological/Topography.java

@@ -911,8 +911,10 @@ public final class Topography
 		}
 
 		int multiplicity = 0;
-		final List<N> edgeNodes = edge.getNodes();
-		final Set<E> potentialMultiples = graph.getAdjacentEdges(edge.getNodes().get(0));
+		final Collection<N> edgeNodes = edge.getNodes();
+        if( edgeNodes.isEmpty() )
+            return multiplicity;
+		final Set<E> potentialMultiples = graph.getAdjacentEdges(edge.getNodes().iterator().next());
 		for(final E potentialMultiple : potentialMultiples)
 		{
 			if( potentialMultiple.equals(edge) )
@@ -956,8 +958,10 @@ public final class Topography
 			}
 		}
 
-		final List<N> edgeNodes = edge.getNodes();
-		final Set<E> potentialMultiples = graph.getAdjacentEdges(edge.getNodes().get(0));
+		final Collection<N> edgeNodes = edge.getNodes();
+        if(edgeNodes.isEmpty())
+            return false;
+		final Set<E> potentialMultiples = graph.getAdjacentEdges(edgeNodes.iterator().next());
 		for(final E potentialMultiple : potentialMultiples)
 		{
 			if( potentialMultiple.equals(edge) )
@@ -1183,7 +1187,7 @@ public final class Topography
 		final Set<TraversableCloud<N>> addEdges = new HashSet<TraversableCloud<N>>();
 		for(final TraversableCloud<N> cutEdge : cutEdges)
 		{
-			final List<N> cutEdgeNeighbors = cutEdge.getNodes();
+			final Collection<N> cutEdgeNeighbors = cutEdge.getNodes();
 			cutEdgeNeighbors.removeAll(cutNodes);
 			if( cutEdgeNeighbors.size() != cutEdge.getNodes().size() )
 				removeEdges.add(cutEdge);

src/test/java/com/syncleus/dann/graph/tree/mst/LinkedGraph.java

@@ -40,33 +40,37 @@ public class LinkedGraph<N, E extends TraversableCloud<N>> extends AbstractAdjac
 		this.edges = new LinkedHashSet<E>(edges);
 		for(final E edge : edges)
 		{
-			final List<N> edgeNodes = edge.getNodes();
-			for(int startNodeIndex = 0; startNodeIndex < edgeNodes.size(); startNodeIndex++)
+			final Collection<N> edgeNodes = edge.getNodes();
+            for(N startNode : edgeNodes)
 			{
-				if( !this.nodes.contains(edgeNodes.get(startNodeIndex)) )
+				if( !this.nodes.contains(startNode) )
 					throw new IllegalArgumentException("A node that is an end point in one of the edges was not in the nodes list");
 
-				Set<E> startNeighborEdges = this.neighborEdges.get(edgeNodes.get(startNodeIndex));
+				Set<E> startNeighborEdges = this.neighborEdges.get(startNode);
 				if( startNeighborEdges == null )
 				{
 					startNeighborEdges = new LinkedHashSet<E>();
-					this.neighborEdges.put(edgeNodes.get(startNodeIndex), startNeighborEdges);
+					this.neighborEdges.put(startNode, startNeighborEdges);
 				}
 				startNeighborEdges.add(edge);
 
-				List<N> startNeighborNodes = this.neighborNodes.get(edgeNodes.get(startNodeIndex));
+				List<N> startNeighborNodes = this.neighborNodes.get(startNode);
 				if( startNeighborNodes == null )
 				{
 					startNeighborNodes = new ArrayList<N>();
-					this.neighborNodes.put(edgeNodes.get(startNodeIndex), startNeighborNodes);
+					this.neighborNodes.put(startNode, startNeighborNodes);
 				}
 
-				for(int endNodeIndex = 0; endNodeIndex < edgeNodes.size(); endNodeIndex++)
+                boolean selfEncountered = false;
+                for(N endNode : edgeNodes)
 				{
-					if( startNodeIndex == endNodeIndex )
+					if( startNode.equals(endNode) && !selfEncountered)
+                    {
+                        selfEncountered = true;
 						continue;
+                    }
 
-					startNeighborNodes.add(edgeNodes.get(endNodeIndex));
+					startNeighborNodes.add(endNode);
 				}
 			}
 		}