org.opentripplanner.routing.api.request.preference.RoutingPreferences 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.routing.api.request.preference;

import static java.util.Objects.requireNonNull;
import static org.opentripplanner.framework.lang.ObjectUtils.ifNotNull;

import java.io.Serializable;
import java.util.Objects;
import java.util.function.Consumer;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opentripplanner.routing.api.request.StreetMode;
import org.opentripplanner.street.search.TraverseMode;

/** User/trip cost/time/slack/reluctance search config. */
@SuppressWarnings("UnusedReturnValue")
public final class RoutingPreferences implements Serializable {

  private static final RoutingPreferences DEFAULT = new RoutingPreferences();

  private final TransitPreferences transit;
  private final TransferPreferences transfer;
  private final WalkPreferences walk;
  private final StreetPreferences street;
  private final WheelchairPreferences wheelchair;
  private final BikePreferences bike;
  private final CarPreferences car;
  private final ScooterPreferences scooter;
  private final SystemPreferences system;
  private final ItineraryFilterPreferences itineraryFilter;

  public RoutingPreferences() {
    this.transit = TransitPreferences.DEFAULT;
    this.transfer = TransferPreferences.DEFAULT;
    this.walk = WalkPreferences.DEFAULT;
    this.street = StreetPreferences.DEFAULT;
    this.wheelchair = WheelchairPreferences.DEFAULT;
    this.bike = BikePreferences.DEFAULT;
    this.car = CarPreferences.DEFAULT;
    this.scooter = ScooterPreferences.DEFAULT;
    this.system = SystemPreferences.DEFAULT;
    this.itineraryFilter = ItineraryFilterPreferences.DEFAULT;
  }

  private RoutingPreferences(Builder builder) {
    this.transit = requireNonNull(builder.transit());
    this.transfer = requireNonNull(builder.transfer());
    this.walk = requireNonNull(builder.walk());
    this.wheelchair = requireNonNull(builder.wheelchair());
    this.street = requireNonNull(builder.street());
    this.bike = requireNonNull(builder.bike());
    this.car = requireNonNull(builder.car());
    this.scooter = requireNonNull(builder.scooter());
    this.system = requireNonNull(builder.system());
    this.itineraryFilter = requireNonNull(builder.itineraryFilter());
  }

  public Builder of() {
    return DEFAULT.copyOf();
  }

  public Builder copyOf() {
    return new Builder(this);
  }

  public TransitPreferences transit() {
    return transit;
  }

  public TransferPreferences transfer() {
    return transfer;
  }

  public WalkPreferences walk() {
    return walk;
  }

  public StreetPreferences street() {
    return street;
  }

  /**
   * Preferences for how strict wheel-accessibility settings are
   */
  @Nonnull
  public WheelchairPreferences wheelchair() {
    return wheelchair;
  }

  public BikePreferences bike() {
    return bike;
  }

  public CarPreferences car() {
    return car;
  }

  public ScooterPreferences scooter() {
    return scooter;
  }

  /**
   * Get parking preferences for the traverse mode. Note, only car and bike are supported.
   */
  public VehicleParkingPreferences parking(TraverseMode mode) {
    return mode == TraverseMode.CAR ? car.parking() : bike.parking();
  }

  /**
   * Get rental preferences for the traverse mode. Note, only car, scooter and bike are supported.
   */
  @Nonnull
  public VehicleRentalPreferences rental(TraverseMode mode) {
    return switch (mode) {
      case BICYCLE -> bike.rental();
      case CAR -> car.rental();
      case SCOOTER -> scooter.rental();
      default -> throw new IllegalArgumentException("rental(): Invalid mode " + mode);
    };
  }

  /**
   * Get rental preferences for the traverse mode. Note, only car, scooter and bike are supported.
   */
  @Nullable
  public VehicleRentalPreferences rental(StreetMode mode) {
    return switch (mode) {
      case BIKE_RENTAL -> bike.rental();
      case CAR_RENTAL -> car.rental();
      case SCOOTER_RENTAL -> scooter.rental();
      default -> null;
    };
  }

  @Nonnull
  public ItineraryFilterPreferences itineraryFilter() {
    return itineraryFilter;
  }

  public SystemPreferences system() {
    return system;
  }

  /**
   * The road speed for a specific traverse mode.
   *
   * NOTE, this is only used for tests and doesn't support scooter walking
   */
  public double getSpeed(TraverseMode mode, boolean walkingBike) {
    return switch (mode) {
      case WALK -> walkingBike ? bike.walking().speed() : walk.speed();
      case BICYCLE -> bike.speed();
      case SCOOTER -> scooter.speed();
      default -> throw new IllegalArgumentException("getSpeed(): Invalid mode " + mode);
    };
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    RoutingPreferences that = (RoutingPreferences) o;
    return (
      Objects.equals(transit, that.transit) &&
      Objects.equals(transfer, that.transfer) &&
      Objects.equals(walk, that.walk) &&
      Objects.equals(street, that.street) &&
      Objects.equals(wheelchair, that.wheelchair) &&
      Objects.equals(bike, that.bike) &&
      Objects.equals(car, that.car) &&
      Objects.equals(scooter, that.scooter) &&
      Objects.equals(system, that.system) &&
      Objects.equals(itineraryFilter, that.itineraryFilter)
    );
  }

  @Override
  public int hashCode() {
    return Objects.hash(
      transit,
      transfer,
      walk,
      street,
      wheelchair,
      bike,
      car,
      scooter,
      system,
      itineraryFilter
    );
  }

  public static class Builder {

    private final RoutingPreferences original;
    private TransitPreferences transit = null;
    private TransferPreferences transfer = null;
    private WalkPreferences walk = null;
    private StreetPreferences street = null;
    private WheelchairPreferences wheelchair = null;
    private BikePreferences bike = null;
    private CarPreferences car = null;
    private ScooterPreferences scooter = null;
    private SystemPreferences system = null;
    private ItineraryFilterPreferences itineraryFilter = null;

    public Builder(RoutingPreferences original) {
      this.original = original;
    }

    public RoutingPreferences original() {
      return original;
    }

    public TransitPreferences transit() {
      return transit == null ? original.transit : transit;
    }

    public Builder withTransit(Consumer body) {
      this.transit = ifNotNull(this.transit, original.transit).copyOf().apply(body).build();
      return this;
    }

    public TransferPreferences transfer() {
      return transfer == null ? original.transfer : transfer;
    }

    public Builder withTransfer(Consumer body) {
      this.transfer = ifNotNull(this.transfer, original.transfer).copyOf().apply(body).build();
      return this;
    }

    public WalkPreferences walk() {
      return walk == null ? original.walk() : walk;
    }

    public Builder withWalk(Consumer body) {
      this.walk = ifNotNull(this.walk, original.walk).copyOf().apply(body).build();
      return this;
    }

    public StreetPreferences street() {
      return street == null ? original.street : street;
    }

    public Builder withStreet(Consumer body) {
      this.street = ifNotNull(this.street, original.street).copyOf().apply(body).build();
      return this;
    }

    public WheelchairPreferences wheelchair() {
      return wheelchair == null ? original.wheelchair : wheelchair;
    }

    public Builder withWheelchair(WheelchairPreferences wheelchair) {
      this.wheelchair = wheelchair;
      return this;
    }

    public Builder withWheelchair(Consumer body) {
      this.wheelchair =
        ifNotNull(this.wheelchair, original.wheelchair).copyOf().apply(body).build();
      return this;
    }

    public BikePreferences bike() {
      return bike == null ? original.bike : bike;
    }

    public Builder withBike(Consumer body) {
      this.bike = ifNotNull(this.bike, original.bike).copyOf().apply(body).build();
      return this;
    }

    public CarPreferences car() {
      return car == null ? original.car : car;
    }

    public Builder withCar(Consumer body) {
      this.car = ifNotNull(this.car, original.car).copyOf().apply(body).build();
      return this;
    }

    public ScooterPreferences scooter() {
      return scooter == null ? original.scooter : scooter;
    }

    public Builder withScooter(Consumer body) {
      this.scooter = ifNotNull(this.scooter, original.scooter).copyOf().apply(body).build();
      return this;
    }

    public SystemPreferences system() {
      return system == null ? original.system : system;
    }

    public Builder withSystem(Consumer body) {
      this.system = ifNotNull(this.system, original.system).copyOf().apply(body).build();
      return this;
    }

    public ItineraryFilterPreferences itineraryFilter() {
      return itineraryFilter == null ? original.itineraryFilter : itineraryFilter;
    }

    public Builder withItineraryFilter(Consumer body) {
      this.itineraryFilter =
        ifNotNull(this.itineraryFilter, original.itineraryFilter).copyOf().apply(body).build();
      return this;
    }

    public Builder apply(Consumer body) {
      body.accept(this);
      return this;
    }

    public RoutingPreferences build() {
      var value = new RoutingPreferences(this);
      return original.equals(value) ? original : value;
    }
  }
}