opentripplanner · t2gran · Dec 16, 2022 · May 6, 2022 · Jan 13, 2023 · Jan 13, 2023
@@ -16,7 +16,14 @@ Be sure to also read the [developer documentation](docs/Developers-Guide.md).
 ## Modules/Components
 
 Below is a list of documented components in OTP. Not every component is documented at a high level,
-but this is a start and we would like to expand this list in the future.
+but this is a start, and we would like to expand this list in the future.
+
+
+### [OTP Transit Model](src/main/java/org/opentripplanner/transit/model/package.md)
+
+Sometimes also referred to as the internal transit model. This is OTPs internal model witch is a
+unified model of GTFS and Transmodel(NeTEx) relevant for OTP. The model is optimized for transit 
+routing.
 
 ### [OTP Configuration design](src/main/java/org/opentripplanner/standalone/config/package.md)
 

@@ -30,6 +30,20 @@ public static int[] intArray(int size, int initialValue) {
     return array;
   }
 
+  /**
+   * Check if each value in the array is equal to the given {@code value}. If all values
+   * are the same and equals to {@code value} or the array is empty this method returns
+   * {@code true}.
+   */
+  public static boolean arrayEquals(int[] array, int value) {
+    for (int i : array) {
+      if (value != i) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   /**
    * Concatenate list a and b and convert them to int arrays.
    */
@@ -49,4 +63,19 @@ public static double standardDeviation(List<Integer> v) {
 
     return Math.sqrt(sum / v.size());
   }
+
+  /**
+   * Add a given {@code delta} value to all elements in an array, except {@code notSet}
+   * elements.
+   */
+  public static int[] arrayPlus(int[] array, int delta) {
+    if (array.length == 0) {
+      return array;
+    }
+    int[] newArray = new int[array.length];
+    for (int i = 0; i < array.length; i++) {
+      newArray[i] = array[i] + delta;
+    }
+    return newArray;
+  }
 }
@@ -1,5 +1,6 @@
 package org.opentripplanner.raptor.api.model;
 
+import java.util.concurrent.atomic.AtomicInteger;
 import org.opentripplanner.raptor.spi.RaptorSlackProvider;
 
 /**
@@ -8,6 +9,8 @@
  * no gaps, as the trips visit the stops.
  */
 public interface RaptorTripPattern {
+  AtomicInteger INDEX_COUNTER = new AtomicInteger(0);
+
   int patternIndex();
 
   /**

@@ -54,12 +54,12 @@ public BestTimes(int nStops, TransitCalculator<?> calculator, WorkerLifeCycle li
     lifeCycle.onPrepareForNextRound(round -> prepareForNextRound());
   }
 
-  public int time(int stop) {
-    return times[stop];
+  public int time(int stopIndex) {
+    return times[stopIndex];
   }
 
-  public int transitArrivalTime(int stop) {
-    return transitArrivalTimes[stop];
+  public int transitArrivalTime(int stopIndex) {
+    return transitArrivalTimes[stopIndex];
   }
 
   /**
@@ -91,25 +91,25 @@ public boolean isStopReachedLastRound(int stop) {
   }
 
   /**
-   * @return return true if stop is reached.
+   * @return return true if stopIndex is reached.
    */
-  public boolean isStopReached(int stop) {
-    return time(stop) != calculator.unreachedTime();
+  public boolean isStopReached(int stopIndex) {
+    return time(stopIndex) != calculator.unreachedTime();
   }
 
   /**
-   * @return return true if stop is reached.
+   * @return return true if stopIndex is reached.
    */
-  public boolean isStopReachedByTransit(int stop) {
-    return transitArrivalTime(stop) != calculator.unreachedTime();
+  public boolean isStopReachedByTransit(int stopIndex) {
+    return transitArrivalTime(stopIndex) != calculator.unreachedTime();
   }
 
   /**
    * @return true iff new best time is updated
    */
-  public boolean updateBestTransitArrivalTime(int stop, int time) {
-    if (isBestTransitArrivalTime(stop, time)) {
-      setBestTime(stop, time);
+  public boolean updateBestTransitArrivalTime(int stopIndex, int time) {
+    if (isBestTransitArrivalTime(stopIndex, time)) {
+      setBestTime(stopIndex, time);
       return true;
     }
     return false;
@@ -118,9 +118,9 @@ public boolean updateBestTransitArrivalTime(int stop, int time) {
   /**
    * @return true iff new best time is updated
    */
-  public boolean updateNewBestTime(int stop, int time) {
-    if (isBestTime(stop, time)) {
-      setTime(stop, time);
+  public boolean updateNewBestTime(int stopIndex, int time) {
+    if (isBestTime(stopIndex, time)) {
+      setTime(stopIndex, time);
       return true;
     }
     return false;
@@ -144,10 +144,10 @@ public String toString() {
   }
 
   /**
-   * @return true if the given stop was reached by on-board in the current round.
+   * @return true if the given stopIndex was reached by on-board in the current round.
    */
-  boolean isStopReachedOnBoardInCurrentRound(int stop) {
-    return reachedByTransitCurrentRound.get(stop);
+  boolean isStopReachedOnBoardInCurrentRound(int stopIndex) {
+    return reachedByTransitCurrentRound.get(stopIndex);
   }
 
   /**
@@ -171,22 +171,22 @@ private void prepareForNextRound() {
 
   /* private methods */
 
-  private void setTime(final int stop, final int time) {
-    times[stop] = time;
-    reachedCurrentRound.set(stop);
+  private void setTime(final int stopIndex, final int time) {
+    times[stopIndex] = time;
+    reachedCurrentRound.set(stopIndex);
   }
 
-  private boolean isBestTime(int stop, int time) {
-    return calculator.isBefore(time, times[stop]);
+  private boolean isBestTime(int stopIndex, int time) {
+    return calculator.isBefore(time, times[stopIndex]);
   }
 
-  private boolean isBestTransitArrivalTime(int stop, int time) {
-    return calculator.isBefore(time, transitArrivalTimes[stop]);
+  private boolean isBestTransitArrivalTime(int stopIndex, int time) {
+    return calculator.isBefore(time, transitArrivalTimes[stopIndex]);
   }
 
-  private void setBestTime(int stop, int time) {
-    transitArrivalTimes[stop] = time;
-    reachedByTransitCurrentRound.set(stop);
+  private void setBestTime(int stopIndex, int time) {
+    transitArrivalTimes[stopIndex] = time;
+    reachedByTransitCurrentRound.set(stopIndex);
   }
 
   private void swapReachedCurrentAndLastRound() {

@@ -10,7 +10,11 @@
  * trip-schedule, so even for long time-tables the Raptor search perform quite well.
  * <p>
  * @param <T> The TripSchedule type defined by the user of the raptor API.
+ * @deprecated TODO RTM - The trip search is modved out of Raptor, so we do not need this class any
+ *                        more. Move the tripSeach() method the RaptorRoute - Try to remove the two
+ *                        other methods.
  */
+@Deprecated
 public interface RaptorTimeTable<T extends RaptorTripSchedule> {
   /**
    * Get trip schedule by index. Trip schedules should be listed in order by the departure time for
@@ -24,7 +28,12 @@ public interface RaptorTimeTable<T extends RaptorTripSchedule> {
 
   /**
    * Number of trips in time-table.
+   * @deprecated TODO RTM - We should get rid of this, it is specific to the period we extract data,
+   *                        but we get into problems when we want to support unbounded periods. Use
+   *                        the trip search instead to find a start point (index) and iterate from
+   *                        there.
    */
+  @Deprecated
   int numberOfTripSchedules();
 
   /**

@@ -9,8 +9,8 @@
 
 /**
  * This {@link java.util.Collection} store all pareto-optimal elements. The {@link #add(Object)}
- * method returns {@code true} if and only if the element was added successfully. When an element is
- * added other elements which are no longer pareto-optimal are dropped.
+ * method returns {@code true} if and only if the element was added successfully. When an element
+ * is added other elements which are no longer pareto-optimal are dropped.
  * <p/>
  * Like the {@link java.util.ArrayList} the elements are stored internally in an array for
  * performance reasons, and the order is guaranteed to be the same as the order the elements are

@@ -4,6 +4,7 @@
 import org.opentripplanner.raptor.spi.RaptorSlackProvider;
 import org.opentripplanner.routing.api.request.framework.DurationForEnum;
 import org.opentripplanner.transit.model.basic.TransitMode;
+import org.opentripplanner.transit.model.network.TripPattern;
 
 /**
  * This class provides transferSlack, boardSlack and alightSlack for the Raptor algorithm.
@@ -64,6 +65,10 @@ private static int[] slackByMode(DurationForEnum<TransitMode> slack) {
     return result;
   }
 
+  public static int slackIndex(TripPattern pattern) {
+    return slackIndex(pattern.getMode());
+  }
+
   public static int slackIndex(final TransitMode mode) {
     return mode.ordinal();
   }