Convert more complex implementations to Comparators

Author: thecoop

lucene/classification/src/java/org/apache/lucene/classification/utils/NearestFuzzyQuery.java

@@ -18,6 +18,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Objects;
@@ -40,6 +41,7 @@
 import org.apache.lucene.search.QueryVisitor;
 import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.FloatComparator;
 import org.apache.lucene.util.PriorityQueue;
 import org.apache.lucene.util.automaton.LevenshteinAutomata;
 
@@ -125,7 +127,8 @@ public void addTerms(String queryString, String fieldName) {
     fieldVals.add(new FieldVals(fieldName, maxEdits, queryString));
   }
 
-  private void addTerms(IndexReader reader, FieldVals f, ScoreTermQueue q) throws IOException {
+  private void addTerms(IndexReader reader, FieldVals f, PriorityQueue<ScoreTerm> q)
+      throws IOException {
     if (f.queryString == null) return;
     final Terms terms = MultiTerms.getTerms(reader, f.fieldName);
     if (terms == null) {
@@ -141,8 +144,8 @@ private void addTerms(IndexReader reader, FieldVals f, ScoreTermQueue q) throws
         String term = termAtt.toString();
         if (!processedTerms.contains(term)) {
           processedTerms.add(term);
-          ScoreTermQueue variantsQ =
-              new ScoreTermQueue(
+          PriorityQueue<ScoreTerm> variantsQ =
+              createScoreTermQueue(
                   MAX_VARIANTS_PER_TERM); // maxNum variants considered for any one term
           float minScore = 0;
           Term startTerm = new Term(f.fieldName, term);
@@ -214,7 +217,7 @@ private Query newTermQuery(IndexReader reader, Term term) throws IOException {
   @Override
   public Query rewrite(IndexSearcher indexSearcher) throws IOException {
     IndexReader reader = indexSearcher.getIndexReader();
-    ScoreTermQueue q = new ScoreTermQueue(MAX_NUM_TERMS);
+    PriorityQueue<ScoreTerm> q = createScoreTermQueue(MAX_NUM_TERMS);
     // load up the list of possible terms
     for (FieldVals f : fieldVals) {
       addTerms(reader, f, q);
@@ -275,19 +278,11 @@ private static class ScoreTerm {
     }
   }
 
-  private static class ScoreTermQueue extends PriorityQueue<ScoreTerm> {
-    ScoreTermQueue(int size) {
-      super(size);
-    }
-
-    /* (non-Javadoc)
-     * @see org.apache.lucene.util.PriorityQueue#lessThan(java.lang.Object, java.lang.Object)
-     */
-    @Override
-    protected boolean lessThan(ScoreTerm termA, ScoreTerm termB) {
-      if (termA.score == termB.score) return termA.term.compareTo(termB.term) > 0;
-      else return termA.score < termB.score;
-    }
+  private static PriorityQueue<ScoreTerm> createScoreTermQueue(int size) {
+    return PriorityQueue.usingComparator(
+        size,
+        FloatComparator.<ScoreTerm>comparing(st -> st.score)
+            .thenComparing(st -> st.term, Comparator.reverseOrder()));
   }
 
   @Override

lucene/codecs/src/java/org/apache/lucene/codecs/uniformsplit/sharedterms/STUniformSplitTermsWriter.java

@@ -164,13 +164,14 @@ private Collection<FieldMetadata> writeSingleSegment(
       throws IOException {
     List<FieldMetadata> fieldMetadataList =
         createFieldMetadataList(new FieldsIterator(fields, fieldInfos), maxDoc);
-    TermIteratorQueue<FieldTerms> fieldTermsQueue =
+    PriorityQueue<TermIterator<FieldTerms>> fieldTermsQueue =
         createFieldTermsQueue(fields, fieldMetadataList);
     List<TermIterator<FieldTerms>> groupedFieldTerms = new ArrayList<>(fieldTermsQueue.size());
     List<FieldMetadataTermState> termStates = new ArrayList<>(fieldTermsQueue.size());
 
     while (fieldTermsQueue.size() != 0) {
-      TermIterator<FieldTerms> topFieldTerms = fieldTermsQueue.popTerms();
+      TermIterator<FieldTerms> topFieldTerms = fieldTermsQueue.pop();
+      assert topFieldTerms != null && topFieldTerms.term != null;
       BytesRef term = BytesRef.deepCopyOf(topFieldTerms.term);
       groupByTerm(fieldTermsQueue, topFieldTerms, groupedFieldTerms);
       writePostingLines(term, groupedFieldTerms, normsProducer, termStates);
@@ -190,9 +191,10 @@ private List<FieldMetadata> createFieldMetadataList(Iterator<FieldInfo> fieldInf
     return fieldMetadataList;
   }
 
-  private TermIteratorQueue<FieldTerms> createFieldTermsQueue(
+  private PriorityQueue<TermIterator<FieldTerms>> createFieldTermsQueue(
       Fields fields, List<FieldMetadata> fieldMetadataList) throws IOException {
-    TermIteratorQueue<FieldTerms> fieldQueue = new TermIteratorQueue<>(fieldMetadataList.size());
+    PriorityQueue<TermIterator<FieldTerms>> fieldQueue =
+        PriorityQueue.usingComparator(fieldMetadataList.size(), Comparator.naturalOrder());
     for (FieldMetadata fieldMetadata : fieldMetadataList) {
       Terms terms = fields.terms(fieldMetadata.getFieldInfo().name);
       if (terms != null) {
@@ -207,7 +209,7 @@ private TermIteratorQueue<FieldTerms> createFieldTermsQueue(
   }
 
   private <T> void groupByTerm(
-      TermIteratorQueue<T> termIteratorQueue,
+      PriorityQueue<TermIterator<T>> termIteratorQueue,
       TermIterator<T> topTermIterator,
       List<TermIterator<T>> groupedTermIterators) {
     groupedTermIterators.clear();
@@ -243,7 +245,8 @@ private void writePostingLines(
   }
 
   private <T> void nextTermForIterators(
-      List<? extends TermIterator<T>> termIterators, TermIteratorQueue<T> termIteratorQueue)
+      List<? extends TermIterator<T>> termIterators,
+      PriorityQueue<TermIterator<T>> termIteratorQueue)
       throws IOException {
     for (TermIterator<T> termIterator : termIterators) {
       if (termIterator.nextTerm()) {
@@ -330,15 +333,17 @@ private Collection<FieldMetadata> mergeSegments(
             mergeState.mergeFieldInfos.iterator(), mergeState.segmentInfo.maxDoc());
     Map<String, MergingFieldTerms> fieldTermsMap =
         createMergingFieldTermsMap(fieldMetadataList, mergeState.fieldsProducers.length);
-    TermIteratorQueue<SegmentTerms> segmentTermsQueue = createSegmentTermsQueue(segmentTermsList);
+    PriorityQueue<TermIterator<SegmentTerms>> segmentTermsQueue =
+        createSegmentTermsQueue(segmentTermsList);
     List<TermIterator<SegmentTerms>> groupedSegmentTerms = new ArrayList<>(segmentTermsList.size());
     Map<String, List<SegmentPostings>> fieldPostingsMap =
         CollectionUtil.newHashMap(mergeState.fieldInfos.length);
     List<MergingFieldTerms> groupedFieldTerms = new ArrayList<>(mergeState.fieldInfos.length);
     List<FieldMetadataTermState> termStates = new ArrayList<>(mergeState.fieldInfos.length);
 
     while (segmentTermsQueue.size() != 0) {
-      TermIterator<SegmentTerms> topSegmentTerms = segmentTermsQueue.popTerms();
+      TermIterator<SegmentTerms> topSegmentTerms = segmentTermsQueue.pop();
+      assert topSegmentTerms != null && topSegmentTerms.term != null;
       BytesRef term = BytesRef.deepCopyOf(topSegmentTerms.term);
       groupByTerm(segmentTermsQueue, topSegmentTerms, groupedSegmentTerms);
       combineSegmentsFields(groupedSegmentTerms, fieldPostingsMap);
@@ -364,9 +369,10 @@ private Map<String, MergingFieldTerms> createMergingFieldTermsMap(
     return fieldTermsMap;
   }
 
-  private TermIteratorQueue<SegmentTerms> createSegmentTermsQueue(
+  private PriorityQueue<TermIterator<SegmentTerms>> createSegmentTermsQueue(
       List<TermIterator<SegmentTerms>> segmentTermsList) throws IOException {
-    TermIteratorQueue<SegmentTerms> segmentQueue = new TermIteratorQueue<>(segmentTermsList.size());
+    PriorityQueue<TermIterator<SegmentTerms>> segmentQueue =
+        PriorityQueue.usingComparator(segmentTermsList.size(), Comparator.naturalOrder());
     for (TermIterator<SegmentTerms> segmentTerms : segmentTermsList) {
       if (segmentTerms.nextTerm()) {
         // There is at least one term in the segment
@@ -447,26 +453,7 @@ PostingsEnum getPostings(String fieldName, PostingsEnum reuse, int flags) throws
     }
   }
 
-  private class TermIteratorQueue<T> extends PriorityQueue<TermIterator<T>> {
-
-    TermIteratorQueue(int numFields) {
-      super(numFields);
-    }
-
-    @Override
-    protected boolean lessThan(TermIterator<T> a, TermIterator<T> b) {
-      return a.compareTo(b) < 0;
-    }
-
-    TermIterator<T> popTerms() {
-      TermIterator<T> topTerms = pop();
-      assert topTerms != null;
-      assert topTerms.term != null;
-      return topTerms;
-    }
-  }
-
-  private abstract class TermIterator<T> implements Comparable<TermIterator<T>> {
+  private abstract static class TermIterator<T> implements Comparable<TermIterator<T>> {
 
     BytesRef term;
 
@@ -485,7 +472,7 @@ public int compareTo(TermIterator<T> other) {
     abstract int compareSecondary(TermIterator<T> other);
   }
 
-  private class FieldTerms extends TermIterator<FieldTerms> {
+  private static class FieldTerms extends TermIterator<FieldTerms> {
 
     final FieldMetadata fieldMetadata;
     final TermsEnum termsEnum;
@@ -520,7 +507,7 @@ void resetIterator(BytesRef term, List<SegmentPostings> segmentPostingsList) {
     }
   }
 
-  private class SegmentTerms extends TermIterator<SegmentTerms> {
+  private static class SegmentTerms extends TermIterator<SegmentTerms> {
 
     private final Integer segmentIndex;
     private final STMergingBlockReader mergingBlockReader;

lucene/core/src/java/org/apache/lucene/index/DocIDMerger.java

@@ -145,13 +145,12 @@ private SortedDocIDMerger(List<T> subs, int maxCount) throws IOException {
       }
       this.subs = subs;
       queue =
-          new PriorityQueue<T>(maxCount - 1) {
-            @Override
-            protected boolean lessThan(Sub a, Sub b) {
-              assert a.mappedDocID != b.mappedDocID;
-              return a.mappedDocID < b.mappedDocID;
-            }
-          };
+          PriorityQueue.usingComparator(
+              maxCount - 1,
+              (a, b) -> {
+                assert a.mappedDocID != b.mappedDocID;
+                return Integer.compare(a.mappedDocID, b.mappedDocID);
+              });
       reset();
     }
 

lucene/core/src/java/org/apache/lucene/index/MultiSorter.java

@@ -18,6 +18,7 @@
 package org.apache.lucene.index;
 
 import java.io.IOException;
+import java.util.Comparator;
 import java.util.List;
 import org.apache.lucene.index.MergeState.DocMap;
 import org.apache.lucene.search.Sort;
@@ -82,24 +83,22 @@ static MergeState.DocMap[] sort(Sort sort, List<CodecReader> readers) throws IOE
     int leafCount = readers.size();
 
     PriorityQueue<LeafAndDocID> queue =
-        new PriorityQueue<LeafAndDocID>(leafCount) {
-          @Override
-          public boolean lessThan(LeafAndDocID a, LeafAndDocID b) {
-            for (int i = 0; i < comparables.length; i++) {
-              int cmp = Long.compare(a.valuesAsComparableLongs[i], b.valuesAsComparableLongs[i]);
-              if (cmp != 0) {
-                return reverseMuls[i] * cmp < 0;
-              }
-            }
-
-            // tie-break by docID natural order:
-            if (a.readerIndex != b.readerIndex) {
-              return a.readerIndex < b.readerIndex;
-            } else {
-              return a.docID < b.docID;
-            }
-          }
-        };
+        PriorityQueue.usingComparator(
+            leafCount,
+            ((Comparator<LeafAndDocID>)
+                    (a, b) -> {
+                      for (int i = 0; i < comparables.length; i++) {
+                        int cmp =
+                            Long.compare(
+                                a.valuesAsComparableLongs[i], b.valuesAsComparableLongs[i]);
+                        if (cmp != 0) {
+                          return reverseMuls[i] * cmp;
+                        }
+                      }
+                      return 0;
+                    })
+                .thenComparingInt(ld -> ld.readerIndex)
+                .thenComparingInt(ld -> ld.docID));
 
     PackedLongValues.Builder[] builders = new PackedLongValues.Builder[leafCount];
 

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

@@ -20,6 +20,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import org.apache.lucene.util.FloatComparator;
 import org.apache.lucene.util.PriorityQueue;
 
 /** Base class for Scorers that score disjunctions. */
@@ -88,12 +89,7 @@ private TwoPhase(DocIdSetIterator approximation, float matchCost) {
       super(approximation);
       this.matchCost = matchCost;
       unverifiedMatches =
-          new PriorityQueue<DisiWrapper>(numClauses) {
-            @Override
-            protected boolean lessThan(DisiWrapper a, DisiWrapper b) {
-              return a.matchCost < b.matchCost;
-            }
-          };
+          PriorityQueue.usingComparator(numClauses, FloatComparator.comparing(d -> d.matchCost));
     }
 
     DisiWrapper getSubMatches() throws IOException {

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

@@ -511,18 +511,11 @@ public List<Impact> getImpacts(int level) {
             }
 
             PriorityQueue<SubIterator> pq =
-                new PriorityQueue<>(impacts.length) {
-                  @Override
-                  protected boolean lessThan(SubIterator a, SubIterator b) {
-                    if (a.current == null) { // means iteration is finished
-                      return false;
-                    }
-                    if (b.current == null) {
-                      return true;
-                    }
-                    return Long.compareUnsigned(a.current.norm, b.current.norm) < 0;
-                  }
-                };
+                PriorityQueue.usingComparator(
+                    impacts.length,
+                    Comparator.comparing(
+                        it -> it.current,
+                        Comparator.nullsLast((a, b) -> Long.compareUnsigned(a.norm, b.norm))));
             for (List<Impact> impacts : toMerge) {
               pq.add(new SubIterator(impacts.iterator()));
             }

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

@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.lucene.util;
+
+import java.util.Comparator;
+
+public interface FloatComparator {
+  interface ToFloatFunction<T> {
+    float applyAsFloat(T obj);
+  }
+
+  static <T> Comparator<T> comparing(ToFloatFunction<T> function) {
+    return (a, b) -> Float.compare(function.applyAsFloat(a), function.applyAsFloat(b));
+  }
+
+  int compare(float f1, float f2);
+}

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

@@ -37,6 +37,7 @@
  */
 public abstract class PriorityQueue<T> implements Iterable<T> {
 
+  /** Create a {@code PriorityQueue} that orders elements using the specified {@code comparator} */
   public static <T> PriorityQueue<T> usingComparator(
       int maxSize, Comparator<? super T> comparator) {
     return new PriorityQueue<>(maxSize) {
@@ -47,6 +48,17 @@ protected boolean lessThan(T a, T b) {
     };
   }
 
+  /** Create a {@code PriorityQueue} that orders elements using the specified {@code comparator} */
+  public static <T> PriorityQueue<T> usingComparator(
+      int maxSize, Supplier<T> sentinelObjectSupplier, Comparator<? super T> comparator) {
+    return new PriorityQueue<>(maxSize, sentinelObjectSupplier) {
+      @Override
+      protected boolean lessThan(T a, T b) {
+        return comparator.compare(a, b) < 0;
+      }
+    };
+  }
+
   private int size = 0;
   private final int maxSize;
   private final T[] heap;

lucene/facet/src/java/org/apache/lucene/facet/facetset/MatchingFacetSetsCounts.java

@@ -161,12 +161,8 @@ public FacetResult getTopChildren(int topN, String dim, String... path) throws I
     topN = Math.min(topN, counts.length);
 
     PriorityQueue<Entry> pq =
-        new PriorityQueue<>(topN, () -> new Entry("", 0)) {
-          @Override
-          protected boolean lessThan(Entry a, Entry b) {
-            return compare(a.count, b.count, a.label, b.label) < 0;
-          }
-        };
+        PriorityQueue.usingComparator(
+            topN, () -> new Entry("", 0), (a, b) -> compare(a.count, b.count, a.label, b.label));
 
     int childCount = 0;
     Entry reuse = pq.top();