public virtual void SetScorer(Scorer scorer)
{
}
public override void SetScorer(Scorer scorer)
{
this.scorer = scorer;
}
public virtual void SetScorer(Scorer scorer)
{
collector.SetScorer(scorer);
}
internal PrimaryAdvancedLeapFrogScorer(Weight weight, int firstFilteredDoc, DocIdSetIterator filterIter, Scorer other)
: base(weight, filterIter, other, other)
{
this.firstFilteredDoc = firstFilteredDoc;
this.m_primaryDoc = firstFilteredDoc; // initialize to prevent and advance call to move it further
}
public virtual void SetScorer(Scorer scorer)
{
// we must wrap again here, but using the value passed in as parameter:
collector.SetScorer(new ConstantScorer(outerInstance.outerInstance, scorer, outerInstance.weight, outerInstance.theScore));
}
public QueryFirstBulkScorer(Scorer scorer, IBits filterBits)
{
this.scorer = scorer;
this.filterBits = filterBits;
}
protected internal LeapFrogScorer(Weight weight, DocIdSetIterator primary, DocIdSetIterator secondary, Scorer scorer)
: base(weight)
{
this.primary = primary;
this.secondary = secondary;
this.scorer = scorer;
}
public override TopDocs Rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int topN)
{
ScoreDoc[] hits = (ScoreDoc[])firstPassTopDocs.ScoreDocs.Clone();
Array.Sort(hits, new ComparerAnonymousInnerClassHelper(this));
IList <AtomicReaderContext> leaves = searcher.IndexReader.Leaves;
Weight weight = searcher.CreateNormalizedWeight(query);
// Now merge sort docIDs from hits, with reader's leaves:
int hitUpto = 0;
int readerUpto = -1;
int endDoc = 0;
int docBase = 0;
Scorer scorer = null;
while (hitUpto < hits.Length)
{
ScoreDoc hit = hits[hitUpto];
int docID = hit.Doc;
AtomicReaderContext readerContext = null;
while (docID >= endDoc)
{
readerUpto++;
readerContext = leaves[readerUpto];
endDoc = readerContext.DocBase + readerContext.Reader.MaxDoc;
}
if (readerContext != null)
{
// We advanced to another segment:
docBase = readerContext.DocBase;
scorer = weight.GetScorer(readerContext, null);
}
int targetDoc = docID - docBase;
int actualDoc = scorer.DocID;
if (actualDoc < targetDoc)
{
actualDoc = scorer.Advance(targetDoc);
}
if (actualDoc == targetDoc)
{
// Query did match this doc:
hit.Score = Combine(hit.Score, true, scorer.GetScore());
}
else
{
// Query did not match this doc:
Debug.Assert(actualDoc > targetDoc);
hit.Score = Combine(hit.Score, false, 0.0f);
}
hitUpto++;
}
// TODO: we should do a partial sort (of only topN)
// instead, but typically the number of hits is
// smallish:
Array.Sort(hits, new ComparerAnonymousInnerClassHelper2(this));
if (topN < hits.Length)
{
ScoreDoc[] subset = new ScoreDoc[topN];
Array.Copy(hits, 0, subset, 0, topN);
hits = subset;
}
return(new TopDocs(firstPassTopDocs.TotalHits, hits, hits[0].Score));
}
internal QueryFirstScorer(Weight weight, IBits filterBits, Scorer other)
: base(weight)
{
this.scorer = other;
this.filterBits = filterBits;
}
/// <summary>
/// Returns the scorer to be used for match counting and score summing.
/// Uses the given required scorer and the prohibitedScorers. </summary>
/// <param name="requiredCountingSumScorer"> A required scorer already built. </param>
private Scorer AddProhibitedScorers(Scorer requiredCountingSumScorer)
{
return((prohibitedScorers.Count == 0) ? requiredCountingSumScorer : new ReqExclScorer(requiredCountingSumScorer, ((prohibitedScorers.Count == 1) ? prohibitedScorers[0] : new MinShouldMatchSumScorer(m_weight, prohibitedScorers)))); // no prohibited
}
public void SetScorer(Scorer scorer)
{
this.setScorer(scorer);
}
internal SingleMatchScorer(BooleanScorer2 outerInstance, Scorer scorer)
: base(scorer.m_weight)
{
this.outerInstance = outerInstance;
this.scorer = scorer;
}
private Scorer DualConjunctionSumScorer(/* bool disableCoord, // LUCENENET: Not Referenced */ Scorer req1, Scorer req2) // non counting.
{
return(new ConjunctionScorer(m_weight, new Scorer[] { req1, req2 }));
// All scorers match, so defaultSimilarity always has 1 as
// the coordination factor.
// Therefore the sum of the scores of two scorers
// is used as score.
}
internal DocsAndFreqs(Scorer scorer)
{
this.Scorer = scorer;
this.Cost = scorer.GetCost();
this.Doc = -1;
}
public override TopDocs Rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int topN)
{
ScoreDoc[] hits = (ScoreDoc[])firstPassTopDocs.ScoreDocs.Clone();
Array.Sort(hits, Comparer <ScoreDoc> .Create((a, b) => a.Doc - b.Doc));
IList <AtomicReaderContext> leaves = searcher.IndexReader.Leaves;
Weight weight = searcher.CreateNormalizedWeight(query);
// Now merge sort docIDs from hits, with reader's leaves:
int hitUpto = 0;
int readerUpto = -1;
int endDoc = 0;
int docBase = 0;
Scorer scorer = null;
while (hitUpto < hits.Length)
{
ScoreDoc hit = hits[hitUpto];
int docID = hit.Doc;
AtomicReaderContext readerContext = null;
while (docID >= endDoc)
{
readerUpto++;
readerContext = leaves[readerUpto];
endDoc = readerContext.DocBase + readerContext.Reader.MaxDoc;
}
if (readerContext != null)
{
// We advanced to another segment:
docBase = readerContext.DocBase;
scorer = weight.GetScorer(readerContext, null);
}
int targetDoc = docID - docBase;
int actualDoc = scorer.DocID;
if (actualDoc < targetDoc)
{
actualDoc = scorer.Advance(targetDoc);
}
if (actualDoc == targetDoc)
{
// Query did match this doc:
hit.Score = Combine(hit.Score, true, scorer.GetScore());
}
else
{
// Query did not match this doc:
if (Debugging.AssertsEnabled)
{
Debugging.Assert(actualDoc > targetDoc);
}
hit.Score = Combine(hit.Score, false, 0.0f);
}
hitUpto++;
}
// TODO: we should do a partial sort (of only topN)
// instead, but typically the number of hits is
// smallish:
Array.Sort(hits, Comparer <ScoreDoc> .Create((a, b) =>
{
// Sort by score descending, then docID ascending:
// LUCENENET specific - compare bits rather than using equality operators to prevent these comparisons from failing in x86 in .NET Framework with optimizations enabled
if (NumericUtils.SingleToSortableInt32(a.Score) > NumericUtils.SingleToSortableInt32(b.Score))
{
return(-1);
}
else if (NumericUtils.SingleToSortableInt32(a.Score) < NumericUtils.SingleToSortableInt32(b.Score))
{
return(1);
}
else
{
// this subtraction can't overflow int
// because docIDs are >= 0:
return(a.Doc - b.Doc);
}
}));
if (topN < hits.Length)
{
ScoreDoc[] subset = new ScoreDoc[topN];
Array.Copy(hits, 0, subset, 0, topN);
hits = subset;
}
return(new TopDocs(firstPassTopDocs.TotalHits, hits, hits[0].Score));
}
public void SetScorer(Scorer scorer)
{
this.scorer = scorer;
}