fixed failed tests

src/main/java/it/unibz/inf/isochrone/algorithm/Isochrone.java

@@ -14,6 +14,7 @@ import it.unibz.inf.isochrone.util.Query;
 
 import java.util.Calendar;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -160,37 +161,19 @@ public abstract class Isochrone {
 		NodeConnection dConnections = null;
 		while ((node = nodeQueue.poll()) != null) {
 			final int nodeId = node.getId();
-			cConnections = new NodeConnection(node);
-			dConnections = new NodeConnection(node);
+			new NodeConnection(node);
 
-			final Collection<Link> adjacents = calcAdjLinks(nodeId);
+			final Collection<Link> targets = calcAdjLinks(nodeId);
 			output.addNode(node);
 			node.close();
 
-			for (final Link link : adjacents) {
-				final boolean isContLink = link.isContinuous();
-				final Node targetNode = getNode(link.getOppositeOf(node));
-				targetNode.visitNrAdjacentLinks((short) 1);
-
-				if (isContLink) {
-					prepareContinousLink(node, link);
-				}
-
-				if (!targetNode.isClosed()) {
-					if (isContLink) {
-						cConnections.addLink(targetNode, link);
-					} else {
-						dConnections.addLink(targetNode, link);
-					}
-				} else if (qIsExpiring && targetNode.isExpired()) {
-					removeNode(targetNode.getId());
-				}
-			}
-
+			cConnections = prepareContinuousLinks(node, targets);
 			updateNodeQueue(expandContinuousLinks(cConnections));
-			addLinks(output, cConnections.getAllLinks());
+
+			dConnections = prepareDiscreteLinks(node, targets);
 			updateNodeQueue(expandDiscreteLinks(dConnections));
 
+			addLinks(output, targets);
 			if (qIsExpiring && node.isExpired()) {
 				removeNode(nodeId);
 			}
@@ -230,16 +213,34 @@ public abstract class Isochrone {
 
 	// Private methods
 
+	private void addTargetNode(final NodeConnection nConnection, final Node node, final Link link) {
+		final Node targetNode = getNode(link.getOppositeOf(node));
+		targetNode.visitNrAdjacentLinks((short) 1);
+
+		if (targetNode.isClosed()) {
+			if (qIsExpiring && targetNode.isExpired() && targetNode.getId() != node.getId()) {
+				removeNode(targetNode.getId());
+			}
+		} else {
+			nConnection.addLink(targetNode, link);
+		}
+	}
+
 	/**
 	 * Expand the given continuous link (that is connected to the given node)
 	 * and adjusts the link offsets based on the distance of the current Node
 	 * and the maximum duration of the query.
 	 *
-	 * @param nConnection information about to where start the calculation, where to travel to and which routes are considered
+	 * @param nConnection information about the the sourceNode, its links and reachable nodes
 	 * @return another node, if it can be reached in the available time (or null if time has run out)
 	 */
 	private Collection<Node> expandContinuousLinks(final NodeConnection nConnection) {
-		final double sourceDistance = nConnection.getSourceNode().getDistance();
+		if (!nConnection.containsTargets()) {
+			return Collections.emptyList();
+		}
+
+		final Node sourceNode = nConnection.getSourceNode();
+		final double sourceDistance = sourceNode.getDistance();
 		final Map<Node, Collection<Link>> targets = nConnection.getTargetEntries();
 		final Collection<Entry<Node, Collection<Link>>> entries = targets.entrySet();
 
@@ -247,8 +248,8 @@ public abstract class Isochrone {
 		for (final Entry<Node, Collection<Link>> e : entries) {
 			final Node targetNode = e.getKey();
 			final Collection<Link> targetLinks = e.getValue();
-			for (final Link l : targetLinks) {
-				final double newDistance = sourceDistance + l.getLength() / qWalkingSpeed;
+			for (final Link link : targetLinks) {
+				final double newDistance = sourceDistance + link.getLength() / qWalkingSpeed;
 				if (newDistance <= qDuration && newDistance < targetNode.getDistance()) {
 					targetNode.setDistance(newDistance);
 					results.add(targetNode);
@@ -265,17 +266,21 @@ public abstract class Isochrone {
 	 * distance of the current Node and the maximum duration of
 	 * the query.
 	 *
-	 * @param nConnection information about to where start the calculation, where to travel to and which routes are considered
-	 * @return another node, if it can be reached in the available time (or null if there is no time to reach another node)
+	 * @param nConnection information about the the sourceNode, its links and reachable nodes
+	 * @return all nodes that can be reached in the available time (or an empty set if there is no time to reach another node)
 	 */
 	private Collection<Node> expandDiscreteLinks(final NodeConnection nConnection) {
+		if (!nConnection.containsTargets()) {
+			return Collections.emptyList();
+		}
+
 		final Map<Node, Long> newDistances = getAdjNodeCost(nConnection);
 		final Collection<Entry<Node, Long>> entries = newDistances.entrySet();
 
 		final Set<Node> results = new LinkedHashSet<>(newDistances.size());
-		for (final Entry<Node, Long> entry : entries) {
-			final Node targetNode = entry.getKey();
-			final Long newDistance = entry.getValue();
+		for (final Entry<Node, Long> e : entries) {
+			final Node targetNode = e.getKey();
+			final long newDistance = e.getValue();
 			if (newDistance <= qDuration && newDistance < targetNode.getDistance()) {
 				targetNode.setDistance(newDistance);
 				results.add(targetNode);
@@ -285,16 +290,6 @@ public abstract class Isochrone {
 		return results;
 	}
 
-	/**
-	 * Get the cost to travel to an adjacent node.
-	 *
-	 * @param nConnection information about to where start the calculation, where to travel to and which routes are considered
-	 * @return the cost of traveling from the node to the target nodes (targetNodeId == mapKey, distance == mapValue)
-	 */
-	private Map<Node, Long> getAdjNodeCost(final NodeConnection nConnection) {
-		return database.getAdjNodeCost(nConnection, dateCodes, qFromTime, qToTime);
-	}
-
 	/**
 	 * Gets date codes for a given time.
 	 *
@@ -305,6 +300,16 @@ public abstract class Isochrone {
 		return database.getDateCodes(time);
 	}
 
+	/**
+	 * Get the cost to travel to an adjacent node.
+	 *
+	 * @param nConnection information about to where start the calculation, where to travel to and which routes are considered
+	 * @return the cost of traveling from the node to adjNode
+	 */
+	private Map<Node, Long> getAdjNodeCost(final NodeConnection nConnection) {
+		return database.getAdjNodeCost(nConnection, dateCodes, qFromTime, qToTime);
+	}
+
 	/**
 	 * Initializes all the locations from which the isochrone should be calculated.
 	 *
@@ -354,10 +359,34 @@ public abstract class Isochrone {
 		}
 	}
 
-	private void prepareContinousLink(final Node node, final Link link) {
-		final double linkLength = link.getLength();
+	private NodeConnection prepareContinuousLinks(final Node node, final Collection<Link> links) {
+		final NodeConnection nConnection = new NodeConnection(node);
 		final double nodeDistance = node.getDistance();
 
+		for (final Link link : links) {
+			if (link.isContinuous()) {
+				prepareLinkOffsets(link, nodeDistance);
+				addTargetNode(nConnection, node, link);
+			}
+		}
+
+		return nConnection;
+	}
+
+	private NodeConnection prepareDiscreteLinks(final Node node, final Collection<Link> links) {
+		final NodeConnection nConnection = new NodeConnection(node);
+		for (final Link link : links) {
+			if (!link.isContinuous()) {
+				addTargetNode(nConnection, node, link);
+			}
+		}
+
+		return nConnection;
+	}
+
+	private void prepareLinkOffsets(final Link link, final double nodeDistance) {
+		final double linkLength = link.getLength();
+
 		if (qIsIncoming) {
 			link.setStartOffset(Math.max(0, linkLength - (qDuration - nodeDistance) * qWalkingSpeed));
 			link.setEndOffset(linkLength);
@@ -400,9 +429,9 @@ public abstract class Isochrone {
 
 	// Private static methods
 
-	private static <T extends AbstractOutput> void addLinks(final T output, final Collection<Link> links) {
+	private static <T extends IOutput> void addLinks(final T output, final Collection<Link> links) {
 		for (final Link link : links) {
-			if (Math.abs(link.getStartOffset() - Double.MIN_VALUE) < COMPARE_PRECISION) {
+			if (link.isContinuous() && Math.abs(link.getStartOffset() - Double.MIN_VALUE) < COMPARE_PRECISION) {
 				output.addLink(link);
 			}
 		}