org.opentripplanner.astar.AStarBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of application Show documentation
The newest version!
package org.opentripplanner.astar;

import java.time.Duration;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import org.opentripplanner.astar.model.GraphPath;
import org.opentripplanner.astar.model.ShortestPathTree;
import org.opentripplanner.astar.spi.AStarEdge;
import org.opentripplanner.astar.spi.AStarState;
import org.opentripplanner.astar.spi.AStarVertex;
import org.opentripplanner.astar.spi.DominanceFunction;
import org.opentripplanner.astar.spi.RemainingWeightHeuristic;
import org.opentripplanner.astar.spi.SearchTerminationStrategy;
import org.opentripplanner.astar.spi.SkipEdgeStrategy;
import org.opentripplanner.astar.spi.TraverseVisitor;

public abstract class AStarBuilder<
  State extends AStarState,
  Edge extends AStarEdge,
  Vertex extends AStarVertex,
  Builder extends AStarBuilder
> {

  private Builder builder;
  private RemainingWeightHeuristic heuristic = RemainingWeightHeuristic.TRIVIAL;
  private SkipEdgeStrategy skipEdgeStrategy;
  private TraverseVisitor traverseVisitor;
  private boolean arriveBy;
  private Set fromVertices;
  private Set toVertices;
  private SearchTerminationStrategy terminationStrategy;
  private DominanceFunction dominanceFunction;
  private Edge originBackEdge;
  private Collection initialStates;

  protected AStarBuilder() {}

  protected void setBuilder(Builder builder) {
    this.builder = builder;
  }

  public Builder setHeuristic(RemainingWeightHeuristic heuristic) {
    this.heuristic = heuristic;
    return builder;
  }

  public Builder setSkipEdgeStrategy(SkipEdgeStrategy skipEdgeStrategy) {
    this.skipEdgeStrategy = skipEdgeStrategy;
    return builder;
  }

  public Builder setTraverseVisitor(TraverseVisitor traverseVisitor) {
    this.traverseVisitor = traverseVisitor;
    return builder;
  }

  public Builder setArriveBy(boolean arriveBy) {
    this.arriveBy = arriveBy;
    return builder;
  }

  protected boolean arriveBy() {
    return arriveBy;
  }

  public Builder setFrom(Set fromVertices) {
    this.fromVertices = fromVertices;
    return builder;
  }

  public Builder setFrom(Vertex fromVertex) {
    this.fromVertices = Collections.singleton(fromVertex);
    return builder;
  }

  public Builder setTo(Set toVertices) {
    this.toVertices = toVertices;
    return builder;
  }

  public Builder setTo(Vertex toVertex) {
    this.toVertices = Collections.singleton(toVertex);
    return builder;
  }

  public Builder setTerminationStrategy(SearchTerminationStrategy terminationStrategy) {
    this.terminationStrategy = terminationStrategy;
    return builder;
  }

  /** The function that compares paths converging on the same vertex to decide which ones continue to be explored. */
  public Builder setDominanceFunction(DominanceFunction dominanceFunction) {
    this.dominanceFunction = dominanceFunction;
    return builder;
  }

  protected abstract Duration streetRoutingTimeout();

  public Builder setOriginBackEdge(Edge originBackEdge) {
    this.originBackEdge = originBackEdge;
    return builder;
  }

  public Builder setInitialStates(Collection initialStates) {
    this.initialStates = initialStates;
    return builder;
  }

  public ShortestPathTree getShortestPathTree() {
    return build().getShortestPathTree();
  }

  public List> getPathsToTarget() {
    return build().getPathsToTarget();
  }

  private AStar build() {
    final Set origin = arriveBy ? toVertices : fromVertices;
    final Set destination = arriveBy ? fromVertices : toVertices;

    Collection initialStates;

    if (this.initialStates != null) {
      initialStates = this.initialStates;
    } else {
      initialStates = createInitialStates(origin);

      if (originBackEdge != null) {
        for (var state : initialStates) {
          state.initBackEdge(originBackEdge);
        }
      }
    }

    prepareInitialStates(initialStates);
    initializeHeuristic(heuristic, origin, destination, arriveBy);

    return new AStar<>(
      heuristic,
      skipEdgeStrategy,
      traverseVisitor,
      arriveBy,
      origin,
      destination,
      terminationStrategy,
      Optional.ofNullable(dominanceFunction).orElseGet(this::createDefaultDominanceFunction),
      streetRoutingTimeout(),
      initialStates
    );
  }

  protected abstract Collection createInitialStates(Set originVertices);

  protected abstract void prepareInitialStates(Collection initialStates);

  protected abstract void initializeHeuristic(
    RemainingWeightHeuristic heuristic,
    Set origin,
    Set destination,
    boolean arriveBy
  );

  protected abstract DominanceFunction createDefaultDominanceFunction();
}