persolijn

RoutingGraph.java (6430B)

---

 package osm.routing;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 /**
  * Represents a routing graph, consisting of nodes and edges, and provides
  * functionality for route calculation.
  *
  * @param <N> The type of nodes in the graph.
  * @param <E> The type of edges connecting the nodes.
  */
 public interface RoutingGraph<N extends RoutingNode<N>, E extends RoutingEdge<N>> {
 
     /**
      * Represents a route in a routing graph, consisting of a target node, a path,
      * and the length of the route.
      *
      * @param <N> The type of nodes in the route.
      */
     public static class Route<N> {
         private final N target;
         private final N[] path;
         private final long length;
 
         /**
          * Constructs a Route object.
          *
          * @param target The target node of the route.
          * @param path   The array of nodes representing the path from the source to the
          *               target.
          * @param length The length of the route.
          */
         public Route(N target, N[] path, long length) {
             this.target = target;
             this.path = path;
             this.length = length;
         }
 
         /**
          * Gets the target node of the route.
          *
          * @return The target node.
          */
         public N getTarget() {
             return target;
         }
 
         /**
          * Checks if the route has a valid path.
          *
          * @return True if the route has a path, false otherwise.
          */
         public boolean hasPath() {
             return path != null;
         }
 
         /**
          * Gets the array of nodes representing the path from the source to the target.
          *
          * @return The array of nodes in the path.
          */
         public N[] getPath() {
             return path;
         }
 
         /**
          * Gets the length of the route.
          *
          * @return The length of the route.
          */
         public long getLength() {
             return length;
         }
     }
 
     /**
      * Calculates the progress between the start and the current node.
      *
      * @param targets The target nodes and their distances.
      * @param start   The starting node.
      * @param offset  The offset value.
      * @param current The current node.
      * @return The progress between the start and current node as a percentage.
      */
     default double getProgress(Map<N, Long> targets, N start, long offset, N current) {
         double startDistance = offset + getStartDistance(start, current);
         return startDistance / (startDistance + getClosestDistance(targets, current));
     }
 
     /**
      * Gets the size of the history for a given node.
      *
      * @param node The node for which to calculate the history size.
      * @return The size of the history for the given node.
      */
     default int getHistorySize(N node) {
         int size = 0;
 
         for (N c = node; c != null; c = c.getParent())
             size++;
 
         return size;
     }
 
     /**
      * Retrieves the history of a node, including itself and its ancestors.
      *
      * @param node The node for which to retrieve the history.
      * @return A list representing the history of the given node.
      */
     default N[] getHistory(N node) {
         N[] path = createHistoryArray(getHistorySize(node));
 
         for (int i = path.length - 1; i >= 0; i--) {
             path[i] = node;
 
             node = node.getParent();
         }
 
         return path;
     }
 
     /**
      * Retrieves the reverse history of a node, starting from itself and going to
      * its ancestors.
      *
      * @param node The node for which to retrieve the reverse history.
      * @return A stream representing the reverse history of the given node.
      */
     default Stream<N> getReverseHistory(N node) {
         return Stream.iterate(node, RoutingNode::hasParent, RoutingNode::getParent);
     }
 
     /**
      * Creates an array to store the history of a node with the given size.
      *
      * @param size The size of the history array.
      * @return An array capable of storing the history of a node.
      */
     N[] createHistoryArray(int size);
 
     /**
      * Calculates a heuristic value for a node based on its distance to target
      * nodes.
      *
      * @param targets The target nodes and their distances.
      * @param node    The node for which to calculate the heuristic.
      * @return The heuristic value for the given node.
      */
     long getHeuristic(Map<N, Long> targets, N node);
 
     /**
      * Calculates the cost of moving from the current node to the next node.
      *
      * @param current The current node.
      * @param next    The next node to move to.
      *                nodes.
      * @return The cost of moving from the current node to the next node.
      */
     long getCost(N current, E next);
 
     /**
      * Iterates over the neighbors of a node and applies the provided consumer
      * function.
      *
      * @param node     The node for which to iterate over neighbors.
      * @param consumer The consumer function to apply to each neighbor.
      */
     void forNeighbor(N node, Consumer<E> consumer);
 
     /**
      * Gets the closest distance from a node to a set of target nodes.
      *
      * @param targets The target nodes and their distances.
      * @param node    The node for which to find the closest distance.
      * @return The closest distance from the node to any of the target nodes.
      */
     long getClosestDistance(Map<N, Long> targets, N node);
 
     /**
      * Called when progress is made during the route calculation.
      *
      * @param progress The progress made, represented as a percentage.
      */
     void onProgress(double progress, N start, Collection<N> targets);
 
     /**
      * Checks if a node is a target node.
      *
      * @param targets The target nodes and their distances.
      * @param node    The node to check.
      * @return {@code true} if the node is a target node, {@code false} otherwise.
      */
     boolean isTarget(Map<N, Long> targets, N node);
 
     /**
      * Gets the distance from the start node to a given node.
      *
      * @param start The start node.
      * @param node  The node for which to calculate the distance.
      * @return The distance from the start node to the given node.
      */
     long getStartDistance(N start, N node);
 }