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

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

@@ -0,0 +1,99 @@
+package org.opentripplanner.model.plan.paging.cursor;
+
+import org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilterResult;
+import org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetterResult;
+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 NumItinerariesFilterResult numItinerariesFilterResult;
+  private final RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult;
+
+  private DefaultPageCursorInput() {
+    this.numItinerariesFilterResult = null;
+    this.removeTransitIfStreetOnlyIsBetterResult = null;
+  }
+
+  private DefaultPageCursorInput(Builder builder) {
+    this.numItinerariesFilterResult = builder.numItinerariesFilterResult();
+    this.removeTransitIfStreetOnlyIsBetterResult =
+      builder.removeTransitIfStreetOnlyIsBetterResult();
+  }
+
+  public static DefaultPageCursorInput.Builder of() {
+    return new Builder(new DefaultPageCursorInput());
+  }
+
+  public DefaultPageCursorInput.Builder copyOf() {
+    return new Builder(this);
+  }
+
+  @Override
+  public NumItinerariesFilterResult numItinerariesFilterResult() {
+    return numItinerariesFilterResult;
+  }
+
+  @Override
+  public RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult() {
+    return removeTransitIfStreetOnlyIsBetterResult;
+  }
+
+  @Override
+  public String toString() {
+    return ToStringBuilder.of(DefaultPageCursorInput.class)
+      .addObj("numItinerariesFilterResult", numItinerariesFilterResult)
+      .addObj("removeTransitIfStreetOnlyIsBetterResult", removeTransitIfStreetOnlyIsBetterResult)
+      .toString();
+  }
+
+  public static class Builder {
+
+    private NumItinerariesFilterResult numItinerariesFilterResult;
+    private RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult;
+
+    public Builder(DefaultPageCursorInput original) {
+      this.numItinerariesFilterResult = original.numItinerariesFilterResult;
+      this.removeTransitIfStreetOnlyIsBetterResult =
+        original.removeTransitIfStreetOnlyIsBetterResult;
+    }
+
+    public NumItinerariesFilterResult numItinerariesFilterResult() {
+      return numItinerariesFilterResult;
+    }
+
+    public Builder withNumItinerariesFilterResult(
+      NumItinerariesFilterResult numItinerariesFilterResult
+    ) {
+      this.numItinerariesFilterResult = numItinerariesFilterResult;
+      return this;
+    }
+
+    public RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult() {
+      return removeTransitIfStreetOnlyIsBetterResult;
+    }
+
+    public Builder withRemoveTransitIfStreetOnlyIsBetterResult(
+      RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult
+    ) {
+      this.removeTransitIfStreetOnlyIsBetterResult = removeTransitIfStreetOnlyIsBetterResult;
+      return this;
+    }
+
+    public DefaultPageCursorInput build() {
+      return new DefaultPageCursorInput(this);
+    }
+  }
+}

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

@@ -6,6 +6,7 @@
 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.utils.tostring.ToStringBuilder;
@@ -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;
@@ -51,18 +52,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.wholeSwUsed = false;
+      this.itineraryPageCut = pageCursorInput.numItinerariesFilterResult().pageCut();
+    }
     return this;
   }
 
@@ -120,34 +126,44 @@ private void createPageCursors() {
     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,23 @@
 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.
+   * 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.
+   * RemoveTransitIfStreetOnlyIsBetterResult contains the best street only cost that 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.
    */
-  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

@@ -12,10 +12,12 @@
 import org.opentripplanner.framework.application.OTPRequestTimeoutException;
 import org.opentripplanner.model.plan.Itinerary;
 import org.opentripplanner.model.plan.grouppriority.TransitGroupPriorityItineraryDecorator;
-import org.opentripplanner.model.plan.paging.cursor.PageCursorInput;
+import org.opentripplanner.model.plan.paging.cursor.DefaultPageCursorInput;
 import org.opentripplanner.raptor.api.request.RaptorTuningParameters;
 import org.opentripplanner.raptor.api.request.SearchParams;
 import org.opentripplanner.routing.algorithm.filterchain.ItineraryListFilterChain;
+import org.opentripplanner.routing.algorithm.filterchain.filters.system.NumItinerariesFilterResult;
+import org.opentripplanner.routing.algorithm.filterchain.filters.transit.RemoveTransitIfStreetOnlyIsBetterResult;
 import org.opentripplanner.routing.algorithm.mapping.PagingServiceFactory;
 import org.opentripplanner.routing.algorithm.mapping.RouteRequestToFilterChainMapper;
 import org.opentripplanner.routing.algorithm.mapping.RoutingResponseMapper;
@@ -63,9 +65,12 @@ public class RoutingWorker {
   private final AdditionalSearchDays additionalSearchDays;
   private final TransitGroupPriorityService transitGroupPriorityService;
   private SearchParams raptorSearchParamsUsed = null;
-  private PageCursorInput pageCursorInput = null;
+  private NumItinerariesFilterResult numItinerariesFilterResult = null;
+  private RemoveTransitIfStreetOnlyIsBetterResult removeTransitIfStreetOnlyIsBetterResult = 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 +97,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());
@@ -136,7 +142,8 @@ public RoutingResponse route() {
         searchWindowUsed(),
         emptyDirectModeHandler.removeWalkAllTheWayResults() ||
         removeWalkAllTheWayResultsFromDirectFlex,
-        it -> pageCursorInput = it
+        it -> numItinerariesFilterResult = it,
+        it -> removeTransitIfStreetOnlyIsBetterResult = it
       );
 
       result.transform(filterChain::filter);
@@ -280,7 +287,10 @@ private PagingService createPagingService(List<Itinerary> itineraries) {
       serverContext.raptorTuningParameters(),
       request,
       raptorSearchParamsUsed,
-      pageCursorInput,
+      DefaultPageCursorInput.of()
+        .withNumItinerariesFilterResult(numItinerariesFilterResult)
+        .withRemoveTransitIfStreetOnlyIsBetterResult(removeTransitIfStreetOnlyIsBetterResult)
+        .build(),
       itineraries
     );
   }