From: Jeremias Maerki Date: Wed, 30 Jan 2008 16:03:00 +0000 (+0000) Subject: Removed the Dijkstra stuff as it was moved to Commons. X-Git-Tag: fop-0_95beta~120 X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=8155c42f8f57693b3b2f06090aed25a72df2c025;p=xmlgraphics-fop.git Removed the Dijkstra stuff as it was moved to Commons. git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/trunk@616798 13f79535-47bb-0310-9956-ffa450edef68 --- diff --git a/src/java/org/apache/fop/util/dijkstra/DefaultEdgeDirectory.java b/src/java/org/apache/fop/util/dijkstra/DefaultEdgeDirectory.java deleted file mode 100644 index 381b356a2..000000000 --- a/src/java/org/apache/fop/util/dijkstra/DefaultEdgeDirectory.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -import java.util.Collections; -import java.util.Iterator; -import java.util.Map; - -/** - * Default implementation of an edge directory for the {@link DijkstraAlgorithm}. - */ -public class DefaultEdgeDirectory implements EdgeDirectory { - - /** The directory of edges */ - private Map edges = new java.util.HashMap(); - //Map> - - /** - * Adds a new edge between two vertices. - * @param edge the new edge - */ - public void addEdge(Edge edge) { - Map directEdges = (Map)edges.get(edge.getStart()); - if (directEdges == null) { - directEdges = new java.util.HashMap(); - edges.put(edge.getStart(), directEdges); - } - directEdges.put(edge.getEnd(), edge); - } - - /** {@inheritDoc} */ - public int getPenalty(Vertex start, Vertex end) { - Map edgeMap = (Map)edges.get(start); - if (edgeMap != null) { - Edge route = (Edge)edgeMap.get(end); - if (route != null) { - int penalty = route.getPenalty(); - if (penalty < 0) { - throw new IllegalStateException("Penalty must not be negative"); - } - return penalty; - } - } - return 0; - } - - /** {@inheritDoc} */ - public Iterator getDestinations(Vertex origin) { - Map directRoutes = (Map)edges.get(origin); - if (directRoutes != null) { - Iterator iter = directRoutes.keySet().iterator(); - return iter; - } - return Collections.EMPTY_LIST.iterator(); - } - - /** - * Returns an iterator over all edges with the given origin. - * @param origin the origin - * @return an iterator over Edge instances - */ - public Iterator getEdges(Vertex origin) { - Map directRoutes = (Map)edges.get(origin); - if (directRoutes != null) { - Iterator iter = directRoutes.values().iterator(); - return iter; - } - return Collections.EMPTY_LIST.iterator(); - } - - /** - * Returns the best edge (the edge with the lowest penalty) between two given vertices. - * @param start the start vertex - * @param end the end vertex - * @return the best vertex or null if none is found - */ - public Edge getBestEdge(Vertex start, Vertex end) { - Edge best = null; - Iterator iter = getEdges(start); - while (iter.hasNext()) { - Edge edge = (Edge)iter.next(); - if (edge.getEnd().equals(end)) { - if (best == null || edge.getPenalty() < best.getPenalty()) { - best = edge; - } - } - } - return best; - } - - -} diff --git a/src/java/org/apache/fop/util/dijkstra/DijkstraAlgorithm.java b/src/java/org/apache/fop/util/dijkstra/DijkstraAlgorithm.java deleted file mode 100644 index a5b2fe202..000000000 --- a/src/java/org/apache/fop/util/dijkstra/DijkstraAlgorithm.java +++ /dev/null @@ -1,215 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -import java.util.Comparator; -import java.util.Iterator; -import java.util.Map; -import java.util.Set; -import java.util.TreeSet; - -/** - * This is an implementation of Dijkstra's algorithm to find the shortest path for a directed - * graph with non-negative edge weights. - * @see WikiPedia on Dijkstra's - * Algorithm - */ -public class DijkstraAlgorithm { - - /** Infinity value for distances. */ - public static final int INFINITE = Integer.MAX_VALUE; - - /** Compares penalties between two possible destinations. */ - private final Comparator penaltyComparator = new Comparator() { - public int compare(Object left, Object right) { - int leftPenalty = getLowestPenalty((Vertex)left); - int rightPenalty = getLowestPenalty((Vertex)right); - if (leftPenalty < rightPenalty) { - return -1; - } else if (leftPenalty == rightPenalty) { - return ((Comparable)left).compareTo(right); - } else { - return 1; - } - } - }; - - /** The directory of edges */ - private EdgeDirectory edgeDirectory; - - /** The priority queue for all vertices under inspection, ordered by penalties/distances. */ - private TreeSet priorityQueue = new TreeSet(penaltyComparator); - //Set - - /** The set of vertices for which the lowest penalty has been found. */ - private Set finishedVertices = new java.util.HashSet(); - //Set - - /** The currently known lowest penalties for all vertices. */ - private Map lowestPenalties = new java.util.HashMap(); - //Map - - /** Map of all predecessors in the spanning tree of best routes. */ - private Map predecessors = new java.util.HashMap(); - //Map - - /** - * Main Constructor. - * @param edgeDirectory the edge directory this instance should work on - */ - public DijkstraAlgorithm(EdgeDirectory edgeDirectory) { - this.edgeDirectory = edgeDirectory; - } - - /** - * Returns the penalty between two vertices. - * @param start the start vertex - * @param end the end vertex - * @return the penalty between two vertices, or 0 if no single edge between the two vertices - * exists. - */ - protected int getPenalty(Vertex start, Vertex end) { - return this.edgeDirectory.getPenalty(start, end); - } - - /** - * Returns an iterator over all valid destinations for a given vertex. - * @param origin the origin from which to search for destinations - * @return the iterator over all valid destinations for a given vertex - */ - protected Iterator getDestinations(Vertex origin) { - return this.edgeDirectory.getDestinations(origin); - } - - private void reset() { - finishedVertices.clear(); - priorityQueue.clear(); - - lowestPenalties.clear(); - predecessors.clear(); - } - - /** - * Run Dijkstra's shortest path algorithm. After this method is finished you can use - * {@link #getPredecessor(Vertex)} to reconstruct the best/shortest path starting from the - * destination backwards. - * @param start the starting vertex - * @param destination the destination vertex. - */ - public void execute(Vertex start, Vertex destination) { - if (start == null || destination == null) { - throw new NullPointerException("start and destination may not be null"); - } - - reset(); - setShortestDistance(start, 0); - priorityQueue.add(start); - - // the current node - Vertex u; - - // extract the vertex with the shortest distance - while (priorityQueue.size() > 0) { - u = (Vertex)priorityQueue.first(); - priorityQueue.remove(u); - - if (destination.equals(u)) { - //Destination reached - break; - } - - finishedVertices.add(u); - relax(u); - } - } - - /** - * Compute new lowest penalties for neighboring vertices. Update the lowest penalties and the - * predecessor map if a better solution is found. - * @param u the vertex to process - */ - private void relax(Vertex u) { - Iterator iter = getDestinations(u); - while (iter.hasNext()) { - Vertex v = (Vertex)iter.next(); - // skip node already settled - if (isFinished(v)) { - continue; - } - - int shortDist = getLowestPenalty(u) + getPenalty(u, v); - - if (shortDist < getLowestPenalty(v)) { - // assign new shortest distance and mark unsettled - setShortestDistance(v, shortDist); - - // assign predecessor in shortest path - setPredecessor(v, u); - } - } - } - - private void setPredecessor(Vertex a, Vertex b) { - predecessors.put(a, b); - } - - /** - * Indicates whether a shortest route to a vertex has been found. - * @param v the vertex - * @return true if the shortest route to this vertex has been found. - */ - private boolean isFinished(Vertex v) { - return finishedVertices.contains(v); - } - - private void setShortestDistance(Vertex vertex, int distance) { - //Remove so it is inserted at the right position after the lowest penalty changes for this - //vertex. - priorityQueue.remove(vertex); - - //Update the lowest penalty. - lowestPenalties.put(vertex, new Integer(distance)); - - //Insert the vertex again at the new position based on the lowest penalty - priorityQueue.add(vertex); - } - - /** - * Returns the lowest penalty from the start point to a given vertex. - * @param vertex the vertex - * @return the lowest penalty or {@link DijkstraAlgorithm#INFINITE} if there is no route to - * the destination. - */ - public int getLowestPenalty(Vertex vertex) { - Integer d = ((Integer)lowestPenalties.get(vertex)); - return (d == null) ? INFINITE : d.intValue(); - } - - /** - * Returns the vertex's predecessor on the shortest path. - * @param vertex the vertex for which to find the predecessor - * @return the vertex's predecessor on the shortest path, or - * null if there is no route to the destination. - */ - public Vertex getPredecessor(Vertex vertex) { - return (Vertex)predecessors.get(vertex); - } - -} diff --git a/src/java/org/apache/fop/util/dijkstra/Edge.java b/src/java/org/apache/fop/util/dijkstra/Edge.java deleted file mode 100644 index f709b9e26..000000000 --- a/src/java/org/apache/fop/util/dijkstra/Edge.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -/** - * Represents an edge (or direct route between two points) for the {@link DijkstraAlgorithm}. - * Implement this class to hold the start and end vertex for an edge and implement the - * getPenalty() method. - */ -public interface Edge { - - /** - * Returns the start vertex of the edge. - * @return the start vertex - */ - Vertex getStart(); - - /** - * Returns the end vertex of the edge. - * @return the end vertex - */ - Vertex getEnd(); - - /** - * Returns the penalty (or distance) for this edge. - * @return the penalty value (must be non-negative) - */ - int getPenalty(); - -} diff --git a/src/java/org/apache/fop/util/dijkstra/EdgeDirectory.java b/src/java/org/apache/fop/util/dijkstra/EdgeDirectory.java deleted file mode 100644 index 6a2dc848b..000000000 --- a/src/java/org/apache/fop/util/dijkstra/EdgeDirectory.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -import java.util.Iterator; - -/** - * Represents a directory of edges for use by the {@link DijkstraAlgorithm}. - */ -public interface EdgeDirectory { - - /** - * Returns the penalty between two vertices. - * @param start the start vertex - * @param end the end vertex - * @return the penalty between two vertices, or 0 if no single edge between the two vertices - * exists. - */ - int getPenalty(Vertex start, Vertex end); - - /** - * Returns an iterator over all valid destinations for a given vertex. - * @param origin the origin from which to search for destinations - * @return the iterator over all valid destinations for a given vertex - */ - Iterator getDestinations(Vertex origin); - -} \ No newline at end of file diff --git a/src/java/org/apache/fop/util/dijkstra/Vertex.java b/src/java/org/apache/fop/util/dijkstra/Vertex.java deleted file mode 100644 index 40c41b0b7..000000000 --- a/src/java/org/apache/fop/util/dijkstra/Vertex.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -/** - * Represents a vertex to be used by {@link DijkstraAlgorithm}. If you want to represent a city, - * you can do "public class City implements Vertex". The purpose of this interface is to make - * sure the Vertex implementation implements the Comparable interface so the sorting order is - * well-defined even when two vertices have the same penalty/distance from an origin point. - * Therefore, make sure you implement the compareTo(Object) and - * equals(Object) methods. - */ -public interface Vertex extends Comparable { - -} diff --git a/test/java/org/apache/fop/util/dijkstra/City.java b/test/java/org/apache/fop/util/dijkstra/City.java deleted file mode 100644 index 4562c36c7..000000000 --- a/test/java/org/apache/fop/util/dijkstra/City.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -/** - * Represents a city. - */ -public class City implements Vertex { - - private String name; - - /** - * Main constructor - * @param name the city's name - */ - public City(String name) { - this.name = name; - } - - /** {@inheritDoc} */ - public boolean equals(Object obj) { - return this.name.equals(((City)obj).name); - } - - /** {@inheritDoc} */ - public int hashCode() { - return this.name.hashCode(); - } - - /** {@inheritDoc} */ - public int compareTo(Object obj) { - return this.name.compareTo(((City)obj).name); - } - - /** {@inheritDoc} */ - public String toString() { - return this.name; - } - -} \ No newline at end of file diff --git a/test/java/org/apache/fop/util/dijkstra/DijkstraTestCase.java b/test/java/org/apache/fop/util/dijkstra/DijkstraTestCase.java deleted file mode 100644 index fb56f1f53..000000000 --- a/test/java/org/apache/fop/util/dijkstra/DijkstraTestCase.java +++ /dev/null @@ -1,139 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -import java.util.Iterator; -import java.util.LinkedList; - -import junit.framework.TestCase; - -/** - * Tests the Dijkstra algorithm implementation. We're comparing best solutions with focus on - * time or distance getting from St. Gallen to Lucerne on Switzerland's railroads. - */ -public class DijkstraTestCase extends TestCase { - - private static final boolean DEBUG = false; - - private static final City ROMANSHORN = new City("Romanshorn"); - private static final City ST_GALLEN = new City("St. Gallen"); - private static final City WINTERTHUR = new City("Winterthur"); - private static final City ZURICH = new City("Zurich"); - private static final City ZUG = new City("Zug"); - private static final City RAPPERSWIL = new City("Rapperswil"); - private static final City ARTH_GOLDAU = new City("Arth-Goldau"); - private static final City LUCERNE = new City("Lucerne"); - - private static final City NOWHERE = new City("nowhere"); - - private DijkstraAlgorithm algo; - private DefaultEdgeDirectory edges; - private Mode mode; - - /** {@inheritDoc} */ - protected void setUp() throws Exception { - super.setUp(); - - edges = new DefaultEdgeDirectory(); - algo = new DijkstraAlgorithm(edges); - mode = new Mode(); - - //St.Gallen - Winterthur - Zurich - Zug - Lucerne: 161 km, 2h 01min - edges.addEdge(new TrainRoute(mode, ST_GALLEN, WINTERTHUR, 61, 39)); - edges.addEdge(new TrainRoute(mode, WINTERTHUR, ZURICH, 31, 31)); - edges.addEdge(new TrainRoute(mode, ZURICH, ZUG, 39, 31)); - edges.addEdge(new TrainRoute(mode, ZUG, LUCERNE, 30, 20)); - - //St.Gallen - Rapperswil - Arth-Goldau - Lucerne: 158km, 2h 18min - edges.addEdge(new TrainRoute(mode, ST_GALLEN, RAPPERSWIL, 72, 57)); - edges.addEdge(new TrainRoute(mode, RAPPERSWIL, ARTH_GOLDAU, 55, 48)); - edges.addEdge(new TrainRoute(mode, ARTH_GOLDAU, LUCERNE, 31, 33)); - - //A detour to make it interesting (St.Gallen - Romanshorn - Winterthur): 89km, 1h 23min - edges.addEdge(new TrainRoute(mode, ST_GALLEN, ROMANSHORN, 30, 32)); - edges.addEdge(new TrainRoute(mode, ROMANSHORN, WINTERTHUR, 59, 51)); - } - - public void testAlgorithmWithDistance() throws Exception { - mode.useDistance(); - City origin = ST_GALLEN; - City destination = LUCERNE; - String route = executeAlgorithm(origin, destination); - - int distance = algo.getLowestPenalty(destination); - - if (DEBUG) { - System.out.println(route + " " + distance + " km"); - } - - assertEquals(158, distance); - assertEquals("St. Gallen - Rapperswil - Arth-Goldau - Lucerne", route); - } - - public void testAlgorithmWithDuration() throws Exception { - mode.useDuration(); - City origin = ST_GALLEN; - City destination = LUCERNE; - String route = executeAlgorithm(origin, destination); - - int duration = algo.getLowestPenalty(destination); - - if (DEBUG) { - System.out.println(route + " " + duration + " minutes"); - } - - assertEquals(121, duration); - assertEquals("St. Gallen - Winterthur - Zurich - Zug - Lucerne", route); - } - - public void testAlgorithmWithNonExistentRoute() throws Exception { - City origin = ST_GALLEN; - City destination = NOWHERE; - algo.execute(origin, destination); - Vertex pred = algo.getPredecessor(destination); - assertNull(pred); - } - - private String executeAlgorithm(City origin, City destination) { - algo.execute(origin, destination); - Vertex prev = destination; - Vertex pred = algo.getPredecessor(destination); - if (pred == null) { - fail("No route found!"); - } - LinkedList stops = new LinkedList(); - stops.addLast(destination); - while ((pred = algo.getPredecessor(prev)) != null) { - stops.addFirst(pred); - prev = pred; - } - StringBuffer sb = new StringBuffer(); - Iterator iter = stops.iterator(); - while (iter.hasNext()) { - if (sb.length() > 0) { - sb.append(" - "); - } - sb.append(iter.next()); - } - String route = sb.toString(); - return route; - } - -} diff --git a/test/java/org/apache/fop/util/dijkstra/Mode.java b/test/java/org/apache/fop/util/dijkstra/Mode.java deleted file mode 100644 index 4e75e57af..000000000 --- a/test/java/org/apache/fop/util/dijkstra/Mode.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -/** - * Class to allow easy switching between duration and distance mode. - */ -public class Mode { - - private boolean duration = true; - - /** - * Switch to duration mode. - */ - public void useDuration() { - this.duration = true; - } - - /** - * Switch to distance mode. - */ - public void useDistance() { - this.duration = false; - } - - /** - * Indicates whether to use duration mode or distance mode. - * @return true if duration mode is active, otherwise it's the distance mode. - */ - public boolean isDuration() { - return this.duration; - } - -} diff --git a/test/java/org/apache/fop/util/dijkstra/TrainRoute.java b/test/java/org/apache/fop/util/dijkstra/TrainRoute.java deleted file mode 100644 index 16ad0dc3a..000000000 --- a/test/java/org/apache/fop/util/dijkstra/TrainRoute.java +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/* $Id$ */ - -package org.apache.fop.util.dijkstra; - -/** - * Represents a train route with both distance and duration. - */ -public class TrainRoute implements Edge { - - private Mode mode; - private Vertex start; - private Vertex end; - private int distance; - private int minutes; - - /** - * Main constructor. - * @param origin the start city - * @param dest the destination city - * @param distance the distance between the two cities - * @param minutes the duration for the route - */ - public TrainRoute(Mode mode, City origin, City dest, int distance, int minutes) { - this.mode = mode; - this.start = origin; - this.end = dest; - this.distance = distance; - this.minutes = minutes; - } - - /** {@inheritDoc} */ - public int getPenalty() { - if (mode.isDuration()) { - return this.minutes; - } else { - return this.distance; - } - } - - /** {@inheritDoc} */ - public Vertex getEnd() { - return this.end; - } - - /** {@inheritDoc} */ - public Vertex getStart() { - return this.start; - } - -}