Apache Lucene open-source search software
Refactor dummy scorables. (#14046)
Adrien Granda833887be67b
diff --git a/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionBulkScorer.java b/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionBulkScorer.javaindex 3022608233e..defda1ae534 100644--- a/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionBulkScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/BlockMaxConjunctionBulkScorer.java@@ -39,7 +39,7 @@ final class BlockMaxConjunctionBulkScorer extends BulkScorer {private final DocIdSetIterator[] iterators;private final DocIdSetIterator lead1, lead2;private final Scorable scorer1, scorer2;- private final DocAndScore scorable = new DocAndScore();+ private final SimpleScorable scorable = new SimpleScorable();private final double[] sumOfOtherClauses;private final int maxDoc;@@ -202,20 +202,4 @@ final class BlockMaxConjunctionBulkScorer extends BulkScorer {public long cost() {return lead1.cost();}-- private static class DocAndScore extends Scorable {-- float score;- float minCompetitiveScore;-- @Override- public float score() throws IOException {- return score;- }-- @Override- public void setMinCompetitiveScore(float minScore) throws IOException {- this.minCompetitiveScore = minScore;- }- }}diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.javaindex 462396e266e..bae5b77bba4 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanScorer.java@@ -80,7 +80,7 @@ final class BooleanScorer extends BulkScorer {final DisiWrapper[] leads;final HeadPriorityQueue head;final TailPriorityQueue tail;- final Score score = new Score();+ final SimpleScorable score = new SimpleScorable();final int minShouldMatch;final long cost;final boolean needsScores;diff --git a/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java b/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.javaindex 7732445e8cd..576232bab21 100644--- a/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java+++ b/lucene/core/src/java/org/apache/lucene/search/BooleanScorerSupplier.java@@ -251,7 +251,7 @@ final class BooleanScorerSupplier extends ScorerSupplier {throws IOException {final LeafCollector noScoreCollector =new LeafCollector() {- Score fake = new Score();+ SimpleScorable fake = new SimpleScorable();@Overridepublic void setScorer(Scorable scorer) throws IOException {diff --git a/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java b/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.javaindex 8bed66a7f49..138c7ea2b60 100644--- a/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java+++ b/lucene/core/src/java/org/apache/lucene/search/MatchAllDocsQuery.java@@ -53,7 +53,7 @@ public final class MatchAllDocsQuery extends Query {public int score(LeafCollector collector, Bits acceptDocs, int min, int max)throws IOException {max = Math.min(max, maxDoc);- Score scorer = new Score();+ SimpleScorable scorer = new SimpleScorable();scorer.score = score;collector.setScorer(scorer);for (int doc = min; doc < max; ++doc) {diff --git a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.javaindex 93dd1ea91e3..d557c1749df 100644--- a/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/MaxScoreBulkScorer.java@@ -43,8 +43,7 @@ final class MaxScoreBulkScorer extends BulkScorer {// The minimum value of minCompetitiveScore that would produce a more favorable partitioning.float nextMinCompetitiveScore;private final long cost;- float minCompetitiveScore;- private final Score scorable = new Score();+ final SimpleScorable scorable = new SimpleScorable();final double[] maxScoreSums;private final DisiWrapper filter;@@ -127,7 +126,7 @@ final class MaxScoreBulkScorer extends BulkScorer {while (top.doc < outerWindowMax) {scoreInnerWindow(collector, acceptDocs, outerWindowMax, filter);top = essentialQueue.top();- if (minCompetitiveScore >= nextMinCompetitiveScore) {+ if (scorable.minCompetitiveScore >= nextMinCompetitiveScore) {// The minimum competitive score increased substantially, so we can now partition scorers// in a more favorable way.break;@@ -254,7 +253,7 @@ final class MaxScoreBulkScorer extends BulkScorer {// We specialize handling the second best scorer, which seems to help a bit with performance.// But this is the exact same logic as in the below for loop.if ((float) MathUtil.sumUpperBound(score + maxScoreSumAtLead2, allScorers.length)- < minCompetitiveScore) {+ < scorable.minCompetitiveScore) {// a competitive match is not possible according to max scores, skip to the next candidatelead1.doc = lead1.iterator.nextDoc();continue;@@ -272,7 +271,7 @@ final class MaxScoreBulkScorer extends BulkScorer {for (int i = allScorers.length - 3; i >= firstRequiredScorer; --i) {if ((float) MathUtil.sumUpperBound(score + maxScoreSums[i], allScorers.length)- < minCompetitiveScore) {+ < scorable.minCompetitiveScore) {// a competitive match is not possible according to max scores, skip to the next candidatelead1.doc = lead1.iterator.nextDoc();continue outer;@@ -389,7 +388,7 @@ final class MaxScoreBulkScorer extends BulkScorer {for (int i = numNonEssentialClauses - 1; i >= 0; --i) {float maxPossibleScore =(float) MathUtil.sumUpperBound(score + maxScoreSums[i], allScorers.length);- if (maxPossibleScore < minCompetitiveScore) {+ if (maxPossibleScore < scorable.minCompetitiveScore) {// Hit is not competitive.return;}@@ -435,7 +434,7 @@ final class MaxScoreBulkScorer extends BulkScorer {double newMaxScoreSum = maxScoreSum + w.maxWindowScore;float maxScoreSumFloat =(float) MathUtil.sumUpperBound(newMaxScoreSum, firstEssentialScorer + 1);- if (maxScoreSumFloat < minCompetitiveScore) {+ if (maxScoreSumFloat < scorable.minCompetitiveScore) {maxScoreSum = newMaxScoreSum;allScorers[firstEssentialScorer] = w;maxScoreSums[firstEssentialScorer] = maxScoreSum;@@ -473,7 +472,7 @@ final class MaxScoreBulkScorer extends BulkScorer {if (firstRequiredScorer > 1) {maxPossibleScoreWithoutPreviousClause += maxScoreSums[firstRequiredScorer - 2];}- if ((float) maxPossibleScoreWithoutPreviousClause >= minCompetitiveScore) {+ if ((float) maxPossibleScoreWithoutPreviousClause >= scorable.minCompetitiveScore) {break;}// The sum of maximum scores ignoring the previous clause is less than the minimum@@ -507,19 +506,4 @@ final class MaxScoreBulkScorer extends BulkScorer {public long cost() {return cost;}-- private class Score extends Scorable {-- float score;-- @Override- public float score() {- return score;- }-- @Override- public void setMinCompetitiveScore(float minScore) throws IOException {- MaxScoreBulkScorer.this.minCompetitiveScore = minScore;- }- }}diff --git a/lucene/core/src/java/org/apache/lucene/search/Score.java b/lucene/core/src/java/org/apache/lucene/search/Score.javadeleted file mode 100644index fdda8e2d76e..00000000000--- a/lucene/core/src/java/org/apache/lucene/search/Score.java+++ /dev/null@@ -1,30 +0,0 @@-/*- * 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.search;--/**- * Used by {@link BulkScorer}s that need to pass a {@link Scorable} to {@link- * LeafCollector#setScorer}.- */-final class Score extends Scorable {- float score;-- @Override- public float score() {- return score;- }-}diff --git a/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java b/lucene/core/src/java/org/apache/lucene/search/SortRescorer.javaindex e4a4891c570..5ed8e1a0327 100644--- a/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java+++ b/lucene/core/src/java/org/apache/lucene/search/SortRescorer.java@@ -55,7 +55,7 @@ public class SortRescorer extends Rescorer {int docBase = 0;LeafCollector leafCollector = null;- Score score = new Score();+ SimpleScorable score = new SimpleScorable();while (hitUpto < hits.length) {ScoreDoc hit = hits[hitUpto];diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.javaindex 1258dd8b10e..6a3f24a38ef 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanScorer.java@@ -102,7 +102,7 @@ public class TestBooleanScorer extends LuceneTestCase {public int score(LeafCollector collector, Bits acceptDocs, int min, int max)throws IOException {assert min == 0;- collector.setScorer(new Score());+ collector.setScorer(new SimpleScorable());collector.collect(0);return DocIdSetIterator.NO_MORE_DOCS;}diff --git a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.javaindex 7ca3ee39b39..33174c9be3d 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestConstantScoreQuery.java@@ -157,7 +157,7 @@ public class TestConstantScoreQuery extends LuceneTestCase {// for the combined BQ, the scorer should always be BooleanScorer's BucketScorer, because our// scorer supports out-of order collection!- final Class<Score> bucketScorerClass = Score.class;+ final Class<SimpleScorable> bucketScorerClass = SimpleScorable.class;checkHits(searcher, csqbq, csqbq.getBoost(), bucketScorerClass);} finally {IOUtils.close(reader, directory);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMaxScoreBulkScorer.java b/lucene/core/src/test/org/apache/lucene/search/TestMaxScoreBulkScorer.javaindex 2f9fcc2a0fd..7ee46a21a58 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMaxScoreBulkScorer.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMaxScoreBulkScorer.java@@ -658,7 +658,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertEquals(3, scorer.firstRequiredScorer); // no required clauses// less than the minimum score of every clause- scorer.minCompetitiveScore = 0.09f;+ scorer.scorable.minCompetitiveScore = 0.09f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -666,7 +666,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertEquals(3, scorer.firstRequiredScorer); // no required clauses// equal to the maximum score of `the`- scorer.minCompetitiveScore = 0.1f;+ scorer.scorable.minCompetitiveScore = 0.1f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -674,7 +674,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertEquals(3, scorer.firstRequiredScorer); // no required clauses// gt than the minimum score of `the`- scorer.minCompetitiveScore = 0.11f;+ scorer.scorable.minCompetitiveScore = 0.11f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -683,7 +683,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(the, scorer.allScorers[0].scorer);// equal to the sum of the max scores of the and quick- scorer.minCompetitiveScore = 1.1f;+ scorer.scorable.minCompetitiveScore = 1.1f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -692,7 +692,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(the, scorer.allScorers[0].scorer);// greater than the sum of the max scores of the and quick- scorer.minCompetitiveScore = 1.11f;+ scorer.scorable.minCompetitiveScore = 1.11f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -703,7 +703,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// equal to the sum of the max scores of the and fox- scorer.minCompetitiveScore = 1.2f;+ scorer.scorable.minCompetitiveScore = 1.2f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -714,7 +714,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// greater than the sum of the max scores of the and fox- scorer.minCompetitiveScore = 1.21f;+ scorer.scorable.minCompetitiveScore = 1.21f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -725,7 +725,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// equal to the sum of the max scores of quick and fox- scorer.minCompetitiveScore = 2.1f;+ scorer.scorable.minCompetitiveScore = 2.1f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -736,7 +736,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// greater than the sum of the max scores of quick and fox- scorer.minCompetitiveScore = 2.11f;+ scorer.scorable.minCompetitiveScore = 2.11f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -747,7 +747,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// greater than the sum of the max scores of quick and fox- scorer.minCompetitiveScore = 2.11f;+ scorer.scorable.minCompetitiveScore = 2.11f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -758,7 +758,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// equal to the sum of the max scores of all terms- scorer.minCompetitiveScore = 2.2f;+ scorer.scorable.minCompetitiveScore = 2.2f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertTrue(scorer.partitionScorers());@@ -769,7 +769,7 @@ public class TestMaxScoreBulkScorer extends LuceneTestCase {assertSame(fox, scorer.allScorers[2].scorer);// greater than the sum of the max scores of all terms- scorer.minCompetitiveScore = 2.21f;+ scorer.scorable.minCompetitiveScore = 2.21f;Collections.shuffle(Arrays.asList(scorer.allScorers), random());scorer.updateMaxWindowScores(4, 100);assertFalse(scorer.partitionScorers()); // no possible match in this windowdiff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.javaindex d27d026f9a6..b39dff08379 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollector.java@@ -147,7 +147,7 @@ public class TestMultiCollector extends LuceneTestCase {collector1 = new TerminateAfterCollector(collector1, 1);collector2 = new TerminateAfterCollector(collector2, 2);- Scorable scorer = new Score();+ SimpleScorable scorer = new SimpleScorable();List<Collector> collectors = Arrays.asList(collector1, collector2);Collections.shuffle(collectors, random());@@ -333,7 +333,7 @@ public class TestMultiCollector extends LuceneTestCase {final LeafCollector ac = c.getLeafCollector(null);ac.collect(1);c.getLeafCollector(null);- c.getLeafCollector(null).setScorer(new Score());+ c.getLeafCollector(null).setScorer(new SimpleScorable());}@Test@@ -355,7 +355,7 @@ public class TestMultiCollector extends LuceneTestCase {LeafCollector ac = c.getLeafCollector(null);ac.collect(1);ac = c.getLeafCollector(null);- ac.setScorer(new Score());+ ac.setScorer(new SimpleScorable());for (DummyCollector dc : dcs) {assertTrue(dc.collectCalled);@@ -407,23 +407,23 @@ public class TestMultiCollector extends LuceneTestCase {() -> {collector(ScoreMode.COMPLETE_NO_SCORES, ScoreCachingWrappingScorer.class).getLeafCollector(ctx)- .setScorer(new Score());+ .setScorer(new SimpleScorable());});// no collector needs scores => no caching- Collector c1 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);- Collector c2 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());+ Collector c1 = collector(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ Collector c2 = collector(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new SimpleScorable());// only one collector needs scores => no caching- c1 = collector(ScoreMode.COMPLETE, Score.class);- c2 = collector(ScoreMode.COMPLETE_NO_SCORES, Score.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());+ c1 = collector(ScoreMode.COMPLETE, SimpleScorable.class);+ c2 = collector(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new SimpleScorable());// several collectors need scores => cachingc1 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);c2 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new SimpleScorable());reader.close();dir.close();@@ -440,11 +440,11 @@ public class TestMultiCollector extends LuceneTestCase {collector(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);Collector c2 =collector(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new SimpleScorable());c1 = collector(ScoreMode.TOP_SCORES, ScoreCachingWrappingScorer.class);c2 = collector(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new Score());+ MultiCollector.wrap(c1, c2).getLeafCollector(ctx).setScorer(new SimpleScorable());reader.close();dir.close();@@ -498,7 +498,7 @@ public class TestMultiCollector extends LuceneTestCase {Collector mc = MultiCollector.wrap(c1, c2);LeafCollector lc = mc.getLeafCollector(ctx);- lc.setScorer(new Score());+ lc.setScorer(new SimpleScorable());lc.collect(0); // OKassertTrue("c1's collect should be called", c1.collectCalled);assertTrue("c2's collect should be called", c2.collectCalled);@@ -549,21 +549,21 @@ public class TestMultiCollector extends LuceneTestCase {LeafCollector lc = mc.getLeafCollector(ctx);assertFalse(c1.setScorerCalled);assertFalse(c2.setScorerCalled);- lc.setScorer(new Score());+ lc.setScorer(new SimpleScorable());assertTrue(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c1.setScorerCalled = false;c2.setScorerCalled = false;lc.collect(0); // OK- lc.setScorer(new Score());+ lc.setScorer(new SimpleScorable());assertTrue(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c1.setScorerCalled = false;c2.setScorerCalled = false;lc.collect(1); // OK, but c1 should terminate- lc.setScorer(new Score());+ lc.setScorer(new SimpleScorable());assertFalse(c1.setScorerCalled);assertTrue(c2.setScorerCalled);c2.setScorerCalled = false;@@ -573,7 +573,7 @@ public class TestMultiCollector extends LuceneTestCase {() -> {lc.collect(2);});- lc.setScorer(new Score());+ lc.setScorer(new SimpleScorable());assertFalse(c1.setScorerCalled);assertFalse(c2.setScorerCalled);diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.javaindex b25f9afaa72..c3b55b69fef 100644--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiCollectorManager.java@@ -89,19 +89,30 @@ public class TestMultiCollectorManager extends LuceneTestCase {LeafReaderContext ctx = reader.leaves().get(0);// no collector needs scores => no caching- CollectorManager<?, ?> cm1 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);- CollectorManager<?, ?> cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);- new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());+ CollectorManager<?, ?> cm1 =+ collectorManager(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ CollectorManager<?, ?> cm2 =+ collectorManager(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ new MultiCollectorManager(cm1, cm2)+ .newCollector()+ .getLeafCollector(ctx)+ .setScorer(new SimpleScorable());// only one collector needs scores => no caching- cm1 = collectorManager(ScoreMode.COMPLETE, Score.class);- cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, Score.class);- new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());+ cm1 = collectorManager(ScoreMode.COMPLETE, SimpleScorable.class);+ cm2 = collectorManager(ScoreMode.COMPLETE_NO_SCORES, SimpleScorable.class);+ new MultiCollectorManager(cm1, cm2)+ .newCollector()+ .getLeafCollector(ctx)+ .setScorer(new SimpleScorable());// several collectors need scores => cachingcm1 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);cm2 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);- new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());+ new MultiCollectorManager(cm1, cm2)+ .newCollector()+ .getLeafCollector(ctx)+ .setScorer(new SimpleScorable());reader.close();dir.close();@@ -120,13 +131,19 @@ public class TestMultiCollectorManager extends LuceneTestCase {CollectorManager<?, ?> cm2 =collectorManager(ScoreMode.TOP_SCORES, MultiCollector.MinCompetitiveScoreAwareScorable.class);- new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());+ new MultiCollectorManager(cm1, cm2)+ .newCollector()+ .getLeafCollector(ctx)+ .setScorer(new SimpleScorable());// both wrapped collector managers need scores, but one is exhaustive, so they should// see a ScoreCachingWrappingScorer pass in as their scorer:cm1 = collectorManager(ScoreMode.COMPLETE, ScoreCachingWrappingScorer.class);cm2 = collectorManager(ScoreMode.TOP_SCORES, ScoreCachingWrappingScorer.class);- new MultiCollectorManager(cm1, cm2).newCollector().getLeafCollector(ctx).setScorer(new Score());+ new MultiCollectorManager(cm1, cm2)+ .newCollector()+ .getLeafCollector(ctx)+ .setScorer(new SimpleScorable());reader.close();dir.close();