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 otp Show documentation
The OpenTripPlanner multimodal journey planning system
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 javax.annotation.Nonnull;
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;
  }

  @Nonnull
  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();
}