DisjunctionSumScorer.cs

Go to the documentation of this file.

/* 
 * 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.
 */

using System;

using ScorerDocQueue = Lucene.Net.Util.ScorerDocQueue;

namespace Lucene.Net.Search
{
    
    class DisjunctionSumScorer:Scorer
    {
        private int nrScorers;
        
        protected internal System.Collections.Generic.IList<Scorer> subScorers;
        
        private int minimumNrMatchers;
        
        private ScorerDocQueue scorerDocQueue;
        
        private int currentDoc = - 1;
        
        protected internal int nrMatchers = - 1;
        
        private float currentScore = System.Single.NaN;
        
        public DisjunctionSumScorer(System.Collections.Generic.IList<Scorer> subScorers, int minimumNrMatchers):base(null)
        {
            
            nrScorers = subScorers.Count;
            
            if (minimumNrMatchers <= 0)
            {
                throw new System.ArgumentException("Minimum nr of matchers must be positive");
            }
            if (nrScorers <= 1)
            {
                throw new System.ArgumentException("There must be at least 2 subScorers");
            }
            
            this.minimumNrMatchers = minimumNrMatchers;
            this.subScorers = subScorers;
            
            InitScorerDocQueue();
        }
        
        public DisjunctionSumScorer(System.Collections.Generic.IList<Scorer> subScorers)
            : this(subScorers, 1)
        {
        }
        
        private void  InitScorerDocQueue()
        {
            scorerDocQueue = new ScorerDocQueue(nrScorers);
            foreach(Scorer se in subScorers)
            {
                if (se.NextDoc() != NO_MORE_DOCS)
                {
                    // doc() method will be used in scorerDocQueue.
                    scorerDocQueue.Insert(se);
                }
            }
        }
        
        public override void  Score(Collector collector)
        {
            collector.SetScorer(this);
            while (NextDoc() != NO_MORE_DOCS)
            {
                collector.Collect(currentDoc);
            }
        }

        public /*protected internal*/ override bool Score(Collector collector, int max, int firstDocID)
        {
            // firstDocID is ignored since nextDoc() sets 'currentDoc'
            collector.SetScorer(this);
            while (currentDoc < max)
            {
                collector.Collect(currentDoc);
                if (NextDoc() == NO_MORE_DOCS)
                {
                    return false;
                }
            }
            return true;
        }
        
        public override int NextDoc()
        {
            if (scorerDocQueue.Size() < minimumNrMatchers || !AdvanceAfterCurrent())
            {
                currentDoc = NO_MORE_DOCS;
            }
            return currentDoc;
        }
        
        protected internal virtual bool AdvanceAfterCurrent()
        {
            do 
            {
                // repeat until minimum nr of matchers
                currentDoc = scorerDocQueue.TopDoc();
                currentScore = scorerDocQueue.TopScore();
                nrMatchers = 1;
                do 
                {
                    // Until all subscorers are after currentDoc
                    if (!scorerDocQueue.TopNextAndAdjustElsePop())
                    {
                        if (scorerDocQueue.Size() == 0)
                        {
                            break; // nothing more to advance, check for last match.
                        }
                    }
                    if (scorerDocQueue.TopDoc() != currentDoc)
                    {
                        break; // All remaining subscorers are after currentDoc.
                    }
                    currentScore += scorerDocQueue.TopScore();
                    nrMatchers++;
                }
                while (true);
                
                if (nrMatchers >= minimumNrMatchers)
                {
                    return true;
                }
                else if (scorerDocQueue.Size() < minimumNrMatchers)
                {
                    return false;
                }
            }
            while (true);
        }
        
        public override float Score()
        {
            return currentScore;
        }
        
        public override int DocID()
        {
            return currentDoc;
        }
        
        public virtual int NrMatchers()
        {
            return nrMatchers;
        }
        
        public override int Advance(int target)
        {
            if (scorerDocQueue.Size() < minimumNrMatchers)
            {
                return currentDoc = NO_MORE_DOCS;
            }
            if (target <= currentDoc)
            {
                return currentDoc;
            }
            do 
            {
                if (scorerDocQueue.TopDoc() >= target)
                {
                    return AdvanceAfterCurrent()?currentDoc:(currentDoc = NO_MORE_DOCS);
                }
                else if (!scorerDocQueue.TopSkipToAndAdjustElsePop(target))
                {
                    if (scorerDocQueue.Size() < minimumNrMatchers)
                    {
                        return currentDoc = NO_MORE_DOCS;
                    }
                }
            }
            while (true);
        }
    }
}