Add generalizedCostMaxLimit field to the PageCursor to enable using RemoveTransitIfStreetOnlyIsBetter filter with paging

application/src/main/java/org/opentripplanner/framework/token/Token.java

@@ -37,8 +37,8 @@ public Duration getDuration(String fieldName) {
     return (Duration) get(fieldName, TokenType.DURATION);
   }
 
-  public int getInt(String fieldName) {
-    return (int) get(fieldName, TokenType.INT);
+  public Integer getInt(String fieldName) {
+    return (Integer) get(fieldName, TokenType.INT);
   }
 
   public String getString(String fieldName) {

application/src/main/java/org/opentripplanner/framework/token/TokenBuilder.java

@@ -33,7 +33,7 @@ public TokenBuilder withDuration(String fieldName, Duration v) {
     return with(fieldName, TokenType.DURATION, v);
   }
 
-  public TokenBuilder withInt(String fieldName, int v) {
+  public TokenBuilder withInt(String fieldName, Integer v) {
     return with(fieldName, TokenType.INT, v);
   }
 

application/src/main/java/org/opentripplanner/framework/token/TokenType.java

@@ -36,7 +36,7 @@ public String valueToString(@Nullable Object value) {
       case BYTE -> Byte.toString((byte) value);
       case DURATION -> DurationUtils.durationToStr((Duration) value);
       case ENUM -> ((Enum<?>) value).name();
-      case INT -> Integer.toString((int) value);
+      case INT -> Integer.toString((Integer) value);
       case STRING -> (String) value;
       case TIME_INSTANT -> value.toString();
     };

application/src/main/java/org/opentripplanner/model/plan/paging/cursor/DefaultPageCursorInput.java

@@ -0,0 +1,96 @@
+package org.opentripplanner.model.plan.paging.cursor;
+
+import java.util.OptionalInt;
+import org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilterResults;
+import org.opentripplanner.utils.tostring.ToStringBuilder;
+
+/**
+ * This class stores input for the PageCursor. The input is related to the NumItinerariesFilter and RemoveTransitIfStreetOnlyIsBetter.
+ * <p>
+ * The NumItinerariesFilter removes itineraries from a list of itineraries based on the number to
+ * keep and whether it should crop at the head or the tail of the list. This class keeps
+ * the extreme endpoints of the sets of itineraries that were kept and removed, as well as more
+ * details about the first itinerary removed (bottom of the head, or top of the tail) and whether
+ * itineraries were cropped at the head or the tail.
+ * <p>
+ * The {@link org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetter}
+ * filter removes transit itineraries if the best street only itinerary has a lower cost.
+ * This class stores the cost of the best street only itinerary for use with paging.
+ */
+public class DefaultPageCursorInput implements PageCursorInput {
+
+  private final NumItinerariesFilterResults numItinerariesFilterResults;
+  private final OptionalInt streetOnlyCost;
+
+  public DefaultPageCursorInput() {
+    this.numItinerariesFilterResults = null;
+    this.streetOnlyCost = OptionalInt.empty();
+  }
+
+  public DefaultPageCursorInput(Builder builder) {
+    this.numItinerariesFilterResults = builder.numItinerariesFilterResults();
+    this.streetOnlyCost = builder.streetOnlyCost();
+  }
+
+  public static DefaultPageCursorInput.Builder of() {
+    return new Builder(new DefaultPageCursorInput());
+  }
+
+  public DefaultPageCursorInput.Builder copyOf() {
+    return new Builder(this);
+  }
+
+  @Override
+  public NumItinerariesFilterResults numItinerariesFilterResults() {
+    return numItinerariesFilterResults;
+  }
+
+  @Override
+  public OptionalInt streetOnlyCost() {
+    return streetOnlyCost;
+  }
+
+  @Override
+  public String toString() {
+    return ToStringBuilder
+      .of(DefaultPageCursorInput.class)
+      .addObj("numItinerariesFilterResults", numItinerariesFilterResults)
+      .addObj("streetOnlyCost", streetOnlyCost)
+      .toString();
+  }
+
+  public static class Builder {
+
+    private NumItinerariesFilterResults numItinerariesFilterResults;
+    private OptionalInt streetOnlyCost;
+
+    public Builder(DefaultPageCursorInput original) {
+      this.numItinerariesFilterResults = original.numItinerariesFilterResults;
+      this.streetOnlyCost = original.streetOnlyCost;
+    }
+
+    public NumItinerariesFilterResults numItinerariesFilterResults() {
+      return numItinerariesFilterResults;
+    }
+
+    public Builder withNumItinerariesFilterResults(
+      NumItinerariesFilterResults numItinerariesFilterResults
+    ) {
+      this.numItinerariesFilterResults = numItinerariesFilterResults;
+      return this;
+    }
+
+    public OptionalInt streetOnlyCost() {
+      return streetOnlyCost;
+    }
+
+    public Builder withStreetOnlyCost(OptionalInt streetOnlyCost) {
+      this.streetOnlyCost = streetOnlyCost;
+      return this;
+    }
+
+    public DefaultPageCursorInput build() {
+      return new DefaultPageCursorInput(this);
+    }
+  }
+}

application/src/main/java/org/opentripplanner/model/plan/paging/cursor/PageCursor.java

@@ -2,6 +2,7 @@
 
 import java.time.Duration;
 import java.time.Instant;
+import java.util.OptionalInt;
 import javax.annotation.Nullable;
 import org.opentripplanner.model.plan.ItinerarySortKey;
 import org.opentripplanner.model.plan.SortOrder;
@@ -24,11 +25,17 @@ public record PageCursor(
   Instant earliestDepartureTime,
   Instant latestArrivalTime,
   Duration searchWindow,
-  @Nullable ItinerarySortKey itineraryPageCut
+  @Nullable ItinerarySortKey itineraryPageCut,
+  OptionalInt streetOnlyCost
 ) {
   public boolean containsItineraryPageCut() {
     return itineraryPageCut != null;
   }
+
+  public boolean containsStreetOnlyCost() {
+    return streetOnlyCost.isPresent();
+  }
+
   @Nullable
   public String encode() {
     return PageCursorSerializer.encode(this);
@@ -71,6 +78,7 @@ public String toString() {
       .addDuration("searchWindow", searchWindow)
       // This will only include the sort vector, not everything else in the itinerary
       .addObjOp("itineraryPageCut", itineraryPageCut, ItinerarySortKey::keyAsString)
+      .addObj("streetOnlyCost", streetOnlyCost)
       .toString();
   }
 }

application/src/main/java/org/opentripplanner/model/plan/paging/cursor/PageCursorFactory.java

@@ -5,6 +5,7 @@
 
 import java.time.Duration;
 import java.time.Instant;
+import java.util.OptionalInt;
 import javax.annotation.Nullable;
 import org.opentripplanner.model.plan.ItinerarySortKey;
 import org.opentripplanner.model.plan.SortOrder;
@@ -20,7 +21,7 @@ public class PageCursorFactory {
   private Duration currentSearchWindow = null;
   private boolean wholeSwUsed = true;
   private ItinerarySortKey itineraryPageCut = null;
-  private PageCursorInput pageCursorInput = null;
+  private PageCursorInput pageCursorInput = DefaultPageCursorInput.of().build();
 
   private PageCursor nextCursor = null;
   private PageCursor prevCursor = null;
@@ -50,18 +51,23 @@ public PageCursorFactory withOriginalSearch(
   }
 
   /**
+   * This adds the page cursor input to the factory. The cursor input can contain information about filtering results
+   * or the best street only cost.
+   * <p>
    * If there were itineraries removed in the current search because the numItineraries parameter
    * was used, then we want to allow the caller to move within some of the itineraries that were
    * removed in the next and previous pages. This means we will use information from when we cropped
    * the list of itineraries to create the new search encoded in the page cursors. We will also add
    * information necessary for removing potential duplicates when paging.
    *
-   * @param pageCursorFactoryParams contains the result from the {@code PagingDuplicateFilter}
+   * @param pageCursorInput contains the generated page cursor input
    */
-  public PageCursorFactory withRemovedItineraries(PageCursorInput pageCursorFactoryParams) {
-    this.wholeSwUsed = false;
-    this.pageCursorInput = pageCursorFactoryParams;
-    this.itineraryPageCut = pageCursorFactoryParams.pageCut();
+  public PageCursorFactory withPageCursorInput(PageCursorInput pageCursorInput) {
+    this.pageCursorInput = pageCursorInput;
+    if (pageCursorInput.numItinerariesFilterResults() != null) {
+      this.wholeSwUsed = false;
+      this.itineraryPageCut = pageCursorInput.numItinerariesFilterResults().pageCut();
+    }
     return this;
   }
 
@@ -120,26 +126,42 @@ private void createPageCursors() {
     else {
       if (currentPageType == NEXT_PAGE) {
         prevEdt = edtBeforeNewSw();
-        nextEdt = pageCursorInput.earliestRemovedDeparture();
+        nextEdt = pageCursorInput.numItinerariesFilterResults().earliestRemovedDeparture();
       } else {
         // The search-window start and end is [inclusive, exclusive], so to calculate the start of the
         // search-window from the last time included in the search window we need to include one extra
         // minute at the end.
-        prevEdt = pageCursorInput.latestRemovedDeparture().minus(newSearchWindow).plusSeconds(60);
+        prevEdt =
+          pageCursorInput
+            .numItinerariesFilterResults()
+            .latestRemovedDeparture()
+            .minus(newSearchWindow)
+            .plusSeconds(60);
         nextEdt = edtAfterUsedSw();
       }
     }
+
+    OptionalInt streetOnlyCost = pageCursorInput.streetOnlyCost();
     prevCursor =
       new PageCursor(
         PREVIOUS_PAGE,
         sortOrder,
         prevEdt,
         currentLat,
         newSearchWindow,
-        itineraryPageCut
+        itineraryPageCut,
+        streetOnlyCost
       );
     nextCursor =
-      new PageCursor(NEXT_PAGE, sortOrder, nextEdt, null, newSearchWindow, itineraryPageCut);
+      new PageCursor(
+        NEXT_PAGE,
+        sortOrder,
+        nextEdt,
+        null,
+        newSearchWindow,
+        itineraryPageCut,
+        streetOnlyCost
+      );
   }
 
   private Instant edtBeforeNewSw() {

application/src/main/java/org/opentripplanner/model/plan/paging/cursor/PageCursorInput.java

@@ -1,29 +1,24 @@
 package org.opentripplanner.model.plan.paging.cursor;
 
-import java.time.Instant;
-import org.opentripplanner.model.plan.ItinerarySortKey;
+import java.util.OptionalInt;
+import org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilterResults;
 
 /**
- * This class holds information needed to create the next/previous page cursors when there were
- * itineraries removed due to cropping the list of itineraries using the numItineraries parameter.
+ * This class holds information needed to create the next/previous page cursors either when there were
+ * itineraries removed due to cropping the list of itineraries using the numItineraries parameter or
+ * when the {@link org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetter}
+ * filter is used.
  * <p>
  * The Instant fields come from the sets of itineraries that were removed and the ones that were
  * kept as a result of using the numItineraries parameter.
+ * The streetOnlyCost is the cost of the best street only itinerary that was found in the first search.
  */
 public interface PageCursorInput {
+  NumItinerariesFilterResults numItinerariesFilterResults();
   /**
-   * The earliest-removed-departure defines the start of the search-window following the
-   * current window. To include this removed itinerary (and all other removed itineraries)
-   * in the next-page search the search windows must overlap.
+   * The best street only cost comes from taking the cost of the best street only itinerary from the first search.
+   * This is used as a comparison in {@link org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetter}
+   * when paging is used.
    */
-  Instant earliestRemovedDeparture();
-  Instant latestRemovedDeparture();
-
-  /**
-   * In case the result has too many results: The {@code numberOfItineraries} request parameter
-   * is less than the number of itineraries found, then we keep the last itinerary kept and
-   * returned as part of the result. The sort vector will be included in the page-cursor and
-   * used in the next/previous page to filter away duplicates.
-   */
-  ItinerarySortKey pageCut();
+  OptionalInt streetOnlyCost();
 }