public override bool Next() { if (firstTime) { if (!exclScorer.Next()) { exclScorer = null; // exhausted at start } firstTime = false; } if (reqScorer == null) { return(false); } if (!reqScorer.Next()) { reqScorer = null; // exhausted, nothing left return(false); } if (exclScorer == null) { return(true); // reqScorer.next() already returned true } return(ToNonExcluded()); }
/// <summary>Scores and collects all matching documents.</summary> /// <param name="hc">The collector to which all matching documents are passed through /// {@link HitCollector#Collect(int, float)}. /// <br>When this method is used the {@link #Explain(int)} method should not be used. /// </param> public override void Score(HitCollector hc) { if (allowDocsOutOfOrder && requiredScorers.Count == 0 && prohibitedScorers.Count < 32) { // fall back to BooleanScorer, scores documents somewhat out of order BooleanScorer bs = new BooleanScorer(GetSimilarity(), minNrShouldMatch); System.Collections.IEnumerator si = optionalScorers.GetEnumerator(); while (si.MoveNext()) { bs.Add((Scorer)si.Current, false, false); } si = prohibitedScorers.GetEnumerator(); while (si.MoveNext()) { bs.Add((Scorer)si.Current, false, true); } bs.Score(hc); } else { if (countingSumScorer == null) { InitCountingSumScorer(); } while (countingSumScorer.Next()) { hc.Collect(countingSumScorer.Doc(), Score()); } } }
/// <summary>Scores and collects all matching documents.</summary> /// <param name="hc">The collector to which all matching documents are passed through /// {@link HitCollector#Collect(int, float)}. /// <br>When this method is used the {@link #Explain(int)} method should not be used. /// </param> public override void Score(HitCollector hc) { if (countingSumScorer == null) { InitCountingSumScorer(); } while (countingSumScorer.Next()) { hc.Collect(countingSumScorer.Doc(), Score()); } }
public SubScorer(Scorer scorer, bool required, bool prohibited, HitCollector collector, SubScorer next) { this.scorer = scorer; this.done = !scorer.Next(); this.required = required; this.prohibited = prohibited; this.collector = collector; this.next = next; }
/// <summary>Add the scorer for a subquery</summary> /// <param name="scorer">the scorer of a subquery of our associated DisjunctionMaxQuery /// </param> public virtual void Add(Scorer scorer) { if (scorer.Next()) { // Initialize and retain only if it produces docs subScorers.Add(scorer); more = true; } }
public SubScorer(Scorer scorer, bool required, bool prohibited, HitCollector collector, SubScorer next) { this.scorer = scorer; this.done = !scorer.Next(); this.required = required; this.prohibited = prohibited; this.collector = collector; this.next = next; }
/// <summary>Add the scorer for a subquery</summary> /// <param name="scorer">the scorer of a subquery of our associated DisjunctionMaxQuery /// </param> public virtual void Add(Scorer scorer) { if (scorer.Next()) { // Initialize and retain only if it produces docs subScorers.Add(scorer); more = true; } }
/// <summary>Advance all subscorers after the current document determined by the /// top of the <code>scorerQueue</code>. /// Repeat until at least the minimum number of subscorers match on the same /// document and all subscorers are after that document or are exhausted. /// <br>On entry the <code>scorerQueue</code> has at least <code>minimumNrMatchers</code> /// available. At least the scorer with the minimum document number will be advanced. /// </summary> /// <returns> true iff there is a match. /// <br>In case there is a match, </code>currentDoc</code>, </code>currentSumScore</code>, /// and </code>nrMatchers</code> describe the match. /// /// </returns> /// <todo> Investigate whether it is possible to use skipTo() when </todo> /// <summary> the minimum number of matchers is bigger than one, ie. try and use the /// character of ConjunctionScorer for the minimum number of matchers. /// </summary> protected internal virtual bool AdvanceAfterCurrent() { do { // repeat until minimum nr of matchers Scorer top = (Scorer)scorerQueue.Top(); currentDoc = top.Doc(); currentScore = top.Score(); nrMatchers = 1; do { // Until all subscorers are after currentDoc if (top.Next()) { scorerQueue.AdjustTop(); } else { scorerQueue.Pop(); if (scorerQueue.Size() < (minimumNrMatchers - nrMatchers)) { // Not enough subscorers left for a match on this document, // and also no more chance of any further match. return(false); } if (scorerQueue.Size() == 0) { break; // nothing more to advance, check for last match. } } top = (Scorer)scorerQueue.Top(); if (top.Doc() != currentDoc) { break; // All remaining subscorers are after currentDoc. } else { currentScore += top.Score(); nrMatchers++; } }while (true); if (nrMatchers >= minimumNrMatchers) { return(true); } else if (scorerQueue.Size() < minimumNrMatchers) { return(false); } }while (true); }
/// <summary>Called the first time next() or skipTo() is called to /// initialize <code>scorerQueue</code>. /// </summary> private void InitScorerQueue() { System.Collections.IEnumerator si = subScorers.GetEnumerator(); scorerQueue = new ScorerQueue(this, nrScorers); while (si.MoveNext()) { Scorer se = (Scorer)si.Current; if (se.Next()) { // doc() method will be used in scorerQueue. scorerQueue.Insert(se); } } }
public override bool Next() { bool more; do { while (bucketTable.first != null) { // more queued current = bucketTable.first; bucketTable.first = current.next; // pop the queue // check prohibited & required if ((current.bits & prohibitedMask) == 0 && (current.bits & requiredMask) == requiredMask) { return(true); } } // refill the queue more = false; end += BucketTable.SIZE; for (SubScorer sub = scorers; sub != null; sub = sub.next) { Scorer scorer = sub.scorer; while (!sub.done && scorer.Doc() < end) { sub.collector.Collect(scorer.Doc(), scorer.Score()); sub.done = !scorer.Next(); } if (!sub.done) { more = true; } } }while (bucketTable.first != null || more); return(false); }
public override bool Next() { return(scorer.Next()); }