BooleanScorer2.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;

namespace Lucene.Net.Search
{
    
    /* See the description in BooleanScorer.java, comparing
    * BooleanScorer & BooleanScorer2 */
    
    /// <summary>An alternative to BooleanScorer that also allows a minimum number
    /// of optional scorers that should match.
    /// <br/>Implements skipTo(), and has no limitations on the numbers of added scorers.
    /// <br/>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
    /// </summary>
    class BooleanScorer2 : Scorer
    {
        private class AnonymousClassDisjunctionSumScorer:DisjunctionSumScorer
        {
            private void  InitBlock(BooleanScorer2 enclosingInstance)
            {
                this.enclosingInstance = enclosingInstance;
            }
            private BooleanScorer2 enclosingInstance;
            public BooleanScorer2 Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            internal AnonymousClassDisjunctionSumScorer(BooleanScorer2 enclosingInstance, System.Collections.Generic.IList<Scorer> scorers, int minNrShouldMatch)
                : base(scorers, minNrShouldMatch)
            {
                InitBlock(enclosingInstance);
            }
            private int lastScoredDoc = - 1;
            // Save the score of lastScoredDoc, so that we don't compute it more than
            // once in score().
            private float lastDocScore = System.Single.NaN;
            public override float Score()
            {
                int doc = DocID();
                if (doc >= lastScoredDoc)
                {
                    if (doc > lastScoredDoc)
                    {
                        lastDocScore = base.Score();
                        lastScoredDoc = doc;
                    }
                    Enclosing_Instance.coordinator.nrMatchers += base.nrMatchers;
                }
                return lastDocScore;
            }
        }
        private class AnonymousClassConjunctionScorer:ConjunctionScorer
        {
            private void  InitBlock(int requiredNrMatchers, BooleanScorer2 enclosingInstance)
            {
                this.requiredNrMatchers = requiredNrMatchers;
                this.enclosingInstance = enclosingInstance;
            }
            private int requiredNrMatchers;
            private BooleanScorer2 enclosingInstance;
            public BooleanScorer2 Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            internal AnonymousClassConjunctionScorer(int requiredNrMatchers, BooleanScorer2 enclosingInstance, Lucene.Net.Search.Similarity defaultSimilarity, System.Collections.Generic.IList<Scorer> requiredScorers)
                : base(defaultSimilarity, requiredScorers)
            {
                InitBlock(requiredNrMatchers, enclosingInstance);
            }
            private int lastScoredDoc = - 1;
            // Save the score of lastScoredDoc, so that we don't compute it more than
            // once in score().
            private float lastDocScore = System.Single.NaN;
            public override float Score()
            {
                int doc = DocID();
                if (doc >= lastScoredDoc)
                {
                    if (doc > lastScoredDoc)
                    {
                        lastDocScore = base.Score();
                        lastScoredDoc = doc;
                    }
                    Enclosing_Instance.coordinator.nrMatchers += requiredNrMatchers;
                }
                // All scorers match, so defaultSimilarity super.score() always has 1 as
                // the coordination factor.
                // Therefore the sum of the scores of the requiredScorers
                // is used as score.
                return lastDocScore;
            }
        }

        private System.Collections.Generic.List<Scorer> requiredScorers;
        private System.Collections.Generic.List<Scorer> optionalScorers;
        private System.Collections.Generic.List<Scorer> prohibitedScorers;
        
        private class Coordinator
        {
            public Coordinator(BooleanScorer2 enclosingInstance)
            {
                InitBlock(enclosingInstance);
            }
            private void  InitBlock(BooleanScorer2 enclosingInstance)
            {
                this.enclosingInstance = enclosingInstance;
            }
            private BooleanScorer2 enclosingInstance;
            public BooleanScorer2 Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            internal float[] coordFactors = null;
            internal int maxCoord = 0; // to be increased for each non prohibited scorer
            internal int nrMatchers; // to be increased by score() of match counting scorers.
            
            internal virtual void  Init()
            {
                // use after all scorers have been added.
                coordFactors = new float[maxCoord + 1];
                Similarity sim = Enclosing_Instance.Similarity;
                for (int i = 0; i <= maxCoord; i++)
                {
                    coordFactors[i] = sim.Coord(i, maxCoord);
                }
            }
        }
        
        private Coordinator coordinator;
        
        /// <summary>The scorer to which all scoring will be delegated,
        /// except for computing and using the coordination factor.
        /// </summary>
        private Scorer countingSumScorer;
        
        /// <summary>The number of optionalScorers that need to match (if there are any) </summary>
        private int minNrShouldMatch;
        
        private int doc = - 1;
        
        /// <summary> Creates a <see cref="Scorer" /> with the given similarity and lists of required,
        /// prohibited and optional scorers. In no required scorers are added, at least
        /// one of the optional scorers will have to match during the search.
        /// 
        /// </summary>
        /// <param name="similarity">The similarity to be used.
        /// </param>
        /// <param name="minNrShouldMatch">The minimum number of optional added scorers that should match
        /// during the search. In case no required scorers are added, at least
        /// one of the optional scorers will have to match during the search.
        /// </param>
        /// <param name="required">the list of required scorers.
        /// </param>
        /// <param name="prohibited">the list of prohibited scorers.
        /// </param>
        /// <param name="optional">the list of optional scorers.
        /// </param>
        public BooleanScorer2(Similarity similarity, int minNrShouldMatch, 
                                System.Collections.Generic.List<Scorer> required,
                                System.Collections.Generic.List<Scorer> prohibited,
                                System.Collections.Generic.List<Scorer> optional)
            : base(similarity)
        {
            if (minNrShouldMatch < 0)
            {
                throw new System.ArgumentException("Minimum number of optional scorers should not be negative");
            }
            coordinator = new Coordinator(this);
            this.minNrShouldMatch = minNrShouldMatch;
            
            optionalScorers = optional;
            coordinator.maxCoord += optional.Count;
            
            requiredScorers = required;
            coordinator.maxCoord += required.Count;
            
            prohibitedScorers = prohibited;
            
            coordinator.Init();
            countingSumScorer = MakeCountingSumScorer();
        }
        
        /// <summary>Count a scorer as a single match. </summary>
        private class SingleMatchScorer:Scorer
        {
            private void  InitBlock(BooleanScorer2 enclosingInstance)
            {
                this.enclosingInstance = enclosingInstance;
            }
            private BooleanScorer2 enclosingInstance;
            public BooleanScorer2 Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            private Scorer scorer;
            private int lastScoredDoc = - 1;
            // Save the score of lastScoredDoc, so that we don't compute it more than
            // once in score().
            private float lastDocScore = System.Single.NaN;
            
            internal SingleMatchScorer(BooleanScorer2 enclosingInstance, Scorer scorer):base(scorer.Similarity)
            {
                InitBlock(enclosingInstance);
                this.scorer = scorer;
            }
            public override float Score()
            {
                int doc = DocID();
                if (doc >= lastScoredDoc)
                {
                    if (doc > lastScoredDoc)
                    {
                        lastDocScore = scorer.Score();
                        lastScoredDoc = doc;
                    }
                    Enclosing_Instance.coordinator.nrMatchers++;
                }
                return lastDocScore;
            }

            public override int DocID()
            {
                return scorer.DocID();
            }

            public override int NextDoc()
            {
                return scorer.NextDoc();
            }

            public override int Advance(int target)
            {
                return scorer.Advance(target);
            }
        }
        
        private Scorer CountingDisjunctionSumScorer(System.Collections.Generic.List<Scorer> scorers, int minNrShouldMatch)
        {
            // each scorer from the list counted as a single matcher
            return new AnonymousClassDisjunctionSumScorer(this, scorers, minNrShouldMatch);
        }
        
        private static readonly Similarity defaultSimilarity;
        
        private Scorer CountingConjunctionSumScorer(System.Collections.Generic.List<Scorer> requiredScorers)
        {
            // each scorer from the list counted as a single matcher
            int requiredNrMatchers = requiredScorers.Count;
            return new AnonymousClassConjunctionScorer(requiredNrMatchers, this, defaultSimilarity, requiredScorers);
        }
        
        private Scorer DualConjunctionSumScorer(Scorer req1, Scorer req2)
        {
            // non counting.
            return new ConjunctionScorer(defaultSimilarity, 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.
        }
        
        /// <summary>Returns the scorer to be used for match counting and score summing.
        /// Uses requiredScorers, optionalScorers and prohibitedScorers.
        /// </summary>
        private Scorer MakeCountingSumScorer()
        {
            // each scorer counted as a single matcher
            return (requiredScorers.Count == 0)?MakeCountingSumScorerNoReq():MakeCountingSumScorerSomeReq();
        }
        
        private Scorer MakeCountingSumScorerNoReq()
        {
            // No required scorers
            // minNrShouldMatch optional scorers are required, but at least 1
            int nrOptRequired = (minNrShouldMatch < 1)?1:minNrShouldMatch;
            Scorer requiredCountingSumScorer;
            if (optionalScorers.Count > nrOptRequired)
                requiredCountingSumScorer = CountingDisjunctionSumScorer(optionalScorers, nrOptRequired);
            else if (optionalScorers.Count == 1)
                requiredCountingSumScorer = new SingleMatchScorer(this, optionalScorers[0]);
            else
                requiredCountingSumScorer = CountingConjunctionSumScorer(optionalScorers);
            return AddProhibitedScorers(requiredCountingSumScorer);
        }
        
        private Scorer MakeCountingSumScorerSomeReq()
        {
            // At least one required scorer.
            if (optionalScorers.Count == minNrShouldMatch)
            {
                // all optional scorers also required.
                var allReq = new System.Collections.Generic.List<Scorer>(requiredScorers);
                allReq.AddRange(optionalScorers);
                return AddProhibitedScorers(CountingConjunctionSumScorer(allReq));
            }
            else
            {
                // optionalScorers.size() > minNrShouldMatch, and at least one required scorer
                Scorer requiredCountingSumScorer = 
                                    requiredScorers.Count == 1
                                    ? new SingleMatchScorer(this, requiredScorers[0])
                                    : CountingConjunctionSumScorer(requiredScorers);
                if (minNrShouldMatch > 0)
                {
                    // use a required disjunction scorer over the optional scorers
                    return AddProhibitedScorers(DualConjunctionSumScorer(requiredCountingSumScorer, CountingDisjunctionSumScorer(optionalScorers, minNrShouldMatch)));
                }
                else
                {
                    // minNrShouldMatch == 0
                    return new ReqOptSumScorer(AddProhibitedScorers(requiredCountingSumScorer), 
                                               optionalScorers.Count == 1
                                               ? new SingleMatchScorer(this, optionalScorers[0])
                                               : CountingDisjunctionSumScorer(optionalScorers, 1));
                }
            }
        }
        
        /// <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 DisjunctionSumScorer(prohibitedScorers)));
        }
        
        /// <summary>Scores and collects all matching documents.</summary>
        /// <param name="collector">The collector to which all matching documents are passed through.
        /// </param>
        public override void  Score(Collector collector)
        {
            collector.SetScorer(this);
            while ((doc = countingSumScorer.NextDoc()) != NO_MORE_DOCS)
            {
                collector.Collect(doc);
            }
        }
        
        public /*protected internal*/ override bool Score(Collector collector, int max, int firstDocID)
        {
            doc = firstDocID;
            collector.SetScorer(this);
            while (doc < max)
            {
                collector.Collect(doc);
                doc = countingSumScorer.NextDoc();
            }
            return doc != NO_MORE_DOCS;
        }
        
        public override int DocID()
        {
            return doc;
        }
        
        public override int NextDoc()
        {
            return doc = countingSumScorer.NextDoc();
        }
        
        public override float Score()
        {
            coordinator.nrMatchers = 0;
            float sum = countingSumScorer.Score();
            return sum * coordinator.coordFactors[coordinator.nrMatchers];
        }
        
        public override int Advance(int target)
        {
            return doc = countingSumScorer.Advance(target);
        }
        
        static BooleanScorer2()
        {
            defaultSimilarity = Search.Similarity.Default;
        }
    }
}