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

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

@@ -6,8 +6,10 @@
 import java.time.Duration;
 import java.time.Instant;
 import javax.annotation.Nullable;
+import org.opentripplanner.framework.model.Cost;
 import org.opentripplanner.model.plan.ItinerarySortKey;
 import org.opentripplanner.model.plan.SortOrder;
+import org.opentripplanner.routing.algorithm.filterchain.paging.DefaultPageCursorInput;
 import org.opentripplanner.utils.tostring.ToStringBuilder;
 
 public class PageCursorFactory {
@@ -18,9 +20,9 @@ public class PageCursorFactory {
   private Instant currentEdt = null;
   private Instant currentLat = null;
   private Duration currentSearchWindow = null;
-  private boolean wholeSwUsed = true;
+  private boolean wholeSearchWindowUsed = true;
   private ItinerarySortKey itineraryPageCut = null;
-  private PageCursorInput pageCursorInput = null;
+  private PageCursorInput pageCursorInput = DefaultPageCursorInput.of().build();
 
   private PageCursor nextCursor = null;
   private PageCursor prevCursor = null;
@@ -51,18 +53,23 @@ public PageCursorFactory withOriginalSearch(
   }
 
   /**
+   * This adds the page cursor input to the factory. The cursor input contains information about filtering results.
+   * <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 the whole search window was not used (i.e. if there were removed itineraries)
+    if (pageCursorInput.numItinerariesFilterResult() != null) {
+      this.wholeSearchWindowUsed = false;
+      this.itineraryPageCut = pageCursorInput.numItinerariesFilterResult().pageCut();
+    }
     return this;
   }
 
@@ -87,7 +94,7 @@ public String toString() {
       .addDateTime("currentLat", currentLat)
       .addDuration("currentSearchWindow", currentSearchWindow)
       .addDuration("newSearchWindow", newSearchWindow)
-      .addBoolIfTrue("searchWindowCropped", !wholeSwUsed)
+      .addBoolIfTrue("searchWindowCropped", !wholeSearchWindowUsed)
       .addObj("pageCursorFactoryParams", pageCursorInput)
       .addObj("nextCursor", nextCursor)
       .addObj("prevCursor", prevCursor)
@@ -112,42 +119,52 @@ private void createPageCursors() {
     Instant prevEdt;
     Instant nextEdt;
 
-    if (wholeSwUsed) {
+    if (wholeSearchWindowUsed) {
       prevEdt = edtBeforeNewSw();
       nextEdt = edtAfterUsedSw();
     }
     // If the whole search window was not used (i.e. if there were removed itineraries)
     else {
       if (currentPageType == NEXT_PAGE) {
         prevEdt = edtBeforeNewSw();
-        nextEdt = pageCursorInput.earliestRemovedDeparture();
+        nextEdt = pageCursorInput.numItinerariesFilterResult().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
+          .numItinerariesFilterResult()
+          .latestRemovedDeparture()
+          .minus(newSearchWindow)
+          .plusSeconds(60);
         nextEdt = edtAfterUsedSw();
       }
     }
-    // TODO - insert generalizedCostMaxLimit here
+
+    Cost generalizedCostMaxLimit = null;
+    if (pageCursorInput.removeTransitIfStreetOnlyIsBetterResult() != null) {
+      generalizedCostMaxLimit = pageCursorInput
+        .removeTransitIfStreetOnlyIsBetterResult()
+        .generalizedCostMaxLimit();
+    }
+
     prevCursor = new PageCursor(
       PREVIOUS_PAGE,
       sortOrder,
       prevEdt,
       currentLat,
       newSearchWindow,
       itineraryPageCut,
-      null
+      generalizedCostMaxLimit
     );
-    // TODO - insert generalizedCostMaxLimit here
     nextCursor = new PageCursor(
       NEXT_PAGE,
       sortOrder,
       nextEdt,
       null,
       newSearchWindow,
       itineraryPageCut,
-      null
+      generalizedCostMaxLimit
     );
   }
 

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

@@ -1,29 +1,25 @@
 package org.opentripplanner.model.plan.paging.cursor;
 
-import java.time.Instant;
-import org.opentripplanner.model.plan.ItinerarySortKey;
+import org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilterResult;
+import org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetterResult;
 
 /**
- * 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.
- * <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.
+ * 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.
  */
 public interface PageCursorInput {
   /**
-   * 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 itinerary filter chain may crop the search window as a result of reducing the list down to a specified maximum number of itineraries.
+   * This contains the results from {@link org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilter}.
    */
-  Instant earliestRemovedDeparture();
-  Instant latestRemovedDeparture();
-
+  NumItinerariesFilterResult numItinerariesFilterResult();
   /**
-   * 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.
+   * {@link RemoveTransitIfStreetOnlyIsBetterResult} contains a maximum cost for itineraries.
+   * It is calculated by 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.
    */
-  ItinerarySortKey pageCut();
+  RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult();
 }

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

@@ -6,14 +6,11 @@
 import org.opentripplanner.model.plan.ItinerarySortKey;
 import org.opentripplanner.model.plan.SortOrder;
 import org.opentripplanner.utils.lang.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 final class PageCursorSerializer {
 
   private static final byte VERSION_ONE = 1;
   private static final byte VERSION_TWO = 2;
-  private static final Logger LOG = LoggerFactory.getLogger(PageCursor.class);
 
   private static final String TYPE_FIELD = "Type";
   private static final String EDT_FIELD = "EDT";

application/src/main/java/org/opentripplanner/routing/algorithm/RoutingWorker.java

@@ -66,6 +66,8 @@ public class RoutingWorker {
   private PageCursorInput pageCursorInput = null;
 
   public RoutingWorker(OtpServerRequestContext serverContext, RouteRequest request, ZoneId zoneId) {
+    // Applying the page cursor modifies the request by removing the direct mode, for example.
+    // If the page cursor doesn't exist, this function does nothing.
     request.applyPageCursor();
     this.request = request;
     this.serverContext = serverContext;
@@ -92,7 +94,8 @@ public RoutingResponse route() {
     // If no direct mode is set, then we set one.
     // See {@link FilterTransitWhenDirectModeIsEmpty}
     var emptyDirectModeHandler = new FilterTransitWhenDirectModeIsEmpty(
-      request.journey().direct().mode()
+      request.journey().direct().mode(),
+      request.pageCursor() != null
     );
 
     request.journey().direct().setMode(emptyDirectModeHandler.resolveDirectMode());

application/src/main/java/org/opentripplanner/routing/algorithm/filterchain/ItineraryListFilterChain.java

@@ -6,21 +6,25 @@
 import org.opentripplanner.routing.algorithm.filterchain.framework.filterchain.DeleteResultHandler;
 import org.opentripplanner.routing.algorithm.filterchain.framework.filterchain.RoutingErrorsAttacher;
 import org.opentripplanner.routing.algorithm.filterchain.framework.spi.ItineraryListFilter;
+import org.opentripplanner.routing.algorithm.filterchain.paging.PageCursorInputAggregator;
 import org.opentripplanner.routing.api.response.RoutingError;
 
 public class ItineraryListFilterChain {
 
   private final List<ItineraryListFilter> filters;
   private final DeleteResultHandler debugHandler;
+  private final PageCursorInputAggregator pageCursorInputAggregator;
 
   private final List<RoutingError> routingErrors = new ArrayList<>();
 
   public ItineraryListFilterChain(
     List<ItineraryListFilter> filters,
-    DeleteResultHandler debugHandler
+    DeleteResultHandler debugHandler,
+    PageCursorInputAggregator pageCursorInputAggregator
   ) {
     this.debugHandler = debugHandler;
     this.filters = filters;
+    this.pageCursorInputAggregator = pageCursorInputAggregator;
   }
 
   public List<Itinerary> filter(List<Itinerary> itineraries) {
@@ -29,6 +33,8 @@ public List<Itinerary> filter(List<Itinerary> itineraries) {
       result = filter.filter(result);
     }
 
+    pageCursorInputAggregator.providePageCursorInput();
+
     routingErrors.addAll(RoutingErrorsAttacher.computeErrors(itineraries, result));
 
     return debugHandler.filter(result);

application/src/main/java/org/opentripplanner/routing/algorithm/filterchain/ItineraryListFilterChainBuilder.java

@@ -13,6 +13,7 @@
 import javax.annotation.Nullable;
 import org.opentripplanner.ext.accessibilityscore.DecorateWithAccessibilityScore;
 import org.opentripplanner.framework.application.OTPFeature;
+import org.opentripplanner.framework.model.Cost;
 import org.opentripplanner.model.plan.Itinerary;
 import org.opentripplanner.model.plan.ItinerarySortKey;
 import org.opentripplanner.model.plan.SortOrder;
@@ -50,6 +51,7 @@
 import org.opentripplanner.routing.algorithm.filterchain.framework.spi.ItineraryDecorator;
 import org.opentripplanner.routing.algorithm.filterchain.framework.spi.ItineraryListFilter;
 import org.opentripplanner.routing.algorithm.filterchain.framework.spi.RemoveItineraryFlagger;
+import org.opentripplanner.routing.algorithm.filterchain.paging.PageCursorInputAggregator;
 import org.opentripplanner.routing.api.request.framework.CostLinearFunction;
 import org.opentripplanner.routing.api.request.preference.ItineraryFilterDebugProfile;
 import org.opentripplanner.routing.services.TransitAlertService;
@@ -78,7 +80,7 @@ public class ItineraryListFilterChainBuilder {
   private double bikeRentalDistanceRatio;
   private double parkAndRideDurationRatio;
   private CostLinearFunction nonTransitGeneralizedCostLimit;
-  private Consumer<PageCursorInput> pageCursorInputSubscriber;
+  private Consumer<PageCursorInput> pageCursorInputSubscriber = i -> {};
   private Instant earliestDepartureTime = null;
   private Duration searchWindow = null;
   private boolean accessibilityScore;
@@ -89,6 +91,7 @@ public class ItineraryListFilterChainBuilder {
   private double minBikeParkingDistance;
   private boolean removeTransitIfWalkingIsBetter = true;
   private ItinerarySortKey itineraryPageCut;
+  private Cost generalizedCostMaxLimit = null;
   private boolean transitGroupPriorityUsed = false;
   private boolean filterDirectFlexBySearchWindow = true;
 
@@ -272,10 +275,8 @@ public ItineraryListFilterChainBuilder withSearchWindow(
   }
 
   /**
-   * If the maximum number of itineraries is exceeded, then the excess itineraries are removed.
-   * The paging service needs this information to adjust the paging cursor. The 'maxLimit' check is
-   * the last thing* happening in the filter-chain after the final sort. So, if another filter
-   * removes an itinerary, the itinerary is not considered with respect to this limit.
+   * Paging stores information from the original search for use with related requests.
+   * This subscriber stores the input needed for creating the page cursor.
    */
   public ItineraryListFilterChainBuilder withPageCursorInputSubscriber(
     Consumer<PageCursorInput> pageCursorInputSubscriber
@@ -284,6 +285,17 @@ public ItineraryListFilterChainBuilder withPageCursorInputSubscriber(
     return this;
   }
 
+  /**
+   * If the search is done with a page cursor that contains an encoded best street only cost, then
+   * this function adds the information to the {@link RemoveTransitIfStreetOnlyIsBetter} filter.
+   *
+   * @param generalizedCostMaxLimit the best street only cost used in filtering.
+   */
+  public ItineraryListFilterChainBuilder withGeneralizedCostMaxLimit(Cost generalizedCostMaxLimit) {
+    this.generalizedCostMaxLimit = generalizedCostMaxLimit;
+    return this;
+  }
+
   /**
    * If the search is done with a page cursor that contains encoded deduplication parameters, then
    * this function adds the filter that removes duplicates.
@@ -383,6 +395,8 @@ public ItineraryListFilterChainBuilder withTransitAlerts(
   @SuppressWarnings("CollectionAddAllCanBeReplacedWithConstructor")
   public ItineraryListFilterChain build() {
     List<ItineraryListFilter> filters = new ArrayList<>();
+    NumItinerariesFilter numItinerariesFilter = null;
+    RemoveTransitIfStreetOnlyIsBetter removeTransitIfStreetOnlyIsBetter = null;
 
     filters.addAll(buildGroupByTripIdAndDistanceFilters());
 
@@ -433,10 +447,11 @@ public ItineraryListFilterChain build() {
     {
       // Filter transit itineraries by comparing against non-transit using generalized-cost
       if (removeTransitWithHigherCostThanBestOnStreetOnly != null) {
-        addRemoveFilter(
-          filters,
-          new RemoveTransitIfStreetOnlyIsBetter(removeTransitWithHigherCostThanBestOnStreetOnly)
+        removeTransitIfStreetOnlyIsBetter = new RemoveTransitIfStreetOnlyIsBetter(
+          removeTransitWithHigherCostThanBestOnStreetOnly,
+          generalizedCostMaxLimit
         );
+        addRemoveFilter(filters, removeTransitIfStreetOnlyIsBetter);
       }
 
       if (removeTransitIfWalkingIsBetter) {
@@ -490,14 +505,11 @@ public ItineraryListFilterChain build() {
       // Remove itineraries if max limit is set
       if (maxNumberOfItineraries > 0) {
         addSort(filters, SortOrderComparator.comparator(sortOrder));
-        addRemoveFilter(
-          filters,
-          new NumItinerariesFilter(
-            maxNumberOfItineraries,
-            maxNumberOfItinerariesCropSection,
-            pageCursorInputSubscriber
-          )
+        numItinerariesFilter = new NumItinerariesFilter(
+          maxNumberOfItineraries,
+          maxNumberOfItinerariesCropSection
         );
+        addRemoveFilter(filters, numItinerariesFilter);
       }
     }
 
@@ -538,8 +550,13 @@ public ItineraryListFilterChain build() {
     }
 
     var debugHandler = new DeleteResultHandler(debug, maxNumberOfItineraries);
+    PageCursorInputAggregator pageCursorInputAggregator = PageCursorInputAggregator.of()
+      .withNumItinerariesFilter(numItinerariesFilter)
+      .withRemoveTransitIfStreetOnlyIsBetter(removeTransitIfStreetOnlyIsBetter)
+      .withPageCursorInputSubscriber(pageCursorInputSubscriber)
+      .build();
 
-    return new ItineraryListFilterChain(filters, debugHandler);
+    return new ItineraryListFilterChain(filters, debugHandler, pageCursorInputAggregator);
   }
 
   public ItineraryListFilterChainBuilder withFilterDirectFlexBySearchWindow(boolean b) {