Change SloppyPhraseMatcher to use LessThan

Author: thecoop

lucene/core/src/java/org/apache/lucene/search/SloppyPhraseMatcher.java

@@ -94,13 +94,21 @@ public SloppyPhraseMatcher(
     this.numPostings = postings.length;
     this.captureLeadMatch = captureLeadMatch;
     pq =
-        PriorityQueue.usingComparator(
+        PriorityQueue.usingLessThan(
             postings.length,
-            Comparator.<PhrasePositions>comparingInt(pp -> pp.position)
+            (pp1, pp2) -> {
+              if (pp1.position == pp2.position)
                 // same doc and pp.position, so decide by actual term positions.
                 // rely on: pp.position == tp.position - offset.
-                .thenComparingInt(pp -> pp.offset)
-                .thenComparingInt(pp -> pp.ord));
+                if (pp1.offset == pp2.offset) {
+                  return pp1.ord < pp2.ord;
+                } else {
+                  return pp1.offset < pp2.offset;
+                }
+              else {
+                return pp1.position < pp2.position;
+              }
+            });
     phrasePositions = new PhrasePositions[postings.length];
     for (int i = 0; i < postings.length; ++i) {
       phrasePositions[i] =

lucene/core/src/java/org/apache/lucene/util/FloatComparator.java

@@ -19,8 +19,10 @@
 import java.util.Comparator;
 
 /** A specialization of {@link Comparator} that compares {@code float} values */
+@FunctionalInterface
 public interface FloatComparator {
 
+  @FunctionalInterface
   interface ToFloatFunction<T> {
     float applyAsFloat(T obj);
   }

lucene/core/src/java/org/apache/lucene/util/PriorityQueue.java

@@ -37,6 +37,32 @@
  */
 public abstract class PriorityQueue<T> implements Iterable<T> {
 
+  @FunctionalInterface
+  public interface LessThan<T> {
+    boolean lessThan(T a, T b);
+  }
+
+  /** Create a {@code PriorityQueue} that orders elements using the specified {@code lessThan} */
+  public static <T> PriorityQueue<T> usingLessThan(int maxSize, LessThan<? super T> lessThan) {
+    return new PriorityQueue<>(maxSize) {
+      @Override
+      protected boolean lessThan(T a, T b) {
+        return lessThan.lessThan(a, b);
+      }
+    };
+  }
+
+  /** Create a {@code PriorityQueue} that orders elements using the specified {@code lessThan} */
+  public static <T> PriorityQueue<T> usingLessThan(
+      int maxSize, Supplier<T> sentinelObjectSupplier, LessThan<? super T> lessThan) {
+    return new PriorityQueue<>(maxSize, sentinelObjectSupplier) {
+      @Override
+      protected boolean lessThan(T a, T b) {
+        return lessThan.lessThan(a, b);
+      }
+    };
+  }
+
   /** Create a {@code PriorityQueue} that orders elements using the specified {@code comparator} */
   public static <T> PriorityQueue<T> usingComparator(
       int maxSize, Comparator<? super T> comparator) {