beagled/Lucene.Net/Search/TermScorer.cs

   1 /*
   2  * Copyright 2004 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 using System;
  17 using TermDocs = Lucene.Net.Index.TermDocs;
  18 namespace Lucene.Net.Search
  19 {
  20
  21     /// <summary>Expert: A <code>Scorer</code> for documents matching a <code>Term</code>.</summary>
  22     sealed class TermScorer : Scorer
  23         {
  24                 private Weight weight;
  25                 private TermDocs termDocs;
  26                 private byte[] norms;
  27                 private float weightValue;
  28                 private int doc;
  29
  30                 private int[] docs = new int[32]; // buffered doc numbers
  31                 private int[] freqs = new int[32]; // buffered term freqs
  32                 private int pointer;
  33                 private int pointerMax;
  34
  35                 private const int SCORE_CACHE_SIZE = 32;
  36                 private float[] scoreCache = new float[SCORE_CACHE_SIZE];
  37
  38         /// <summary>Construct a <code>TermScorer</code>.</summary>
  39         /// <param name="weight">The weight of the <code>Term</code> in the query.
  40         /// </param>
  41         /// <param name="td">An iterator over the documents matching the <code>Term</code>.
  42         /// </param>
  43         /// <param name="similarity">The </code>Similarity</code> implementation to be used for score computations.
  44         /// </param>
  45         /// <param name="norms">The field norms of the document fields for the <code>Term</code>.
  46         /// </param>
  47         internal TermScorer(Weight weight, TermDocs td, Similarity similarity, byte[] norms) : base(similarity)
  48                 {
  49                         this.weight = weight;
  50                         this.termDocs = td;
  51                         this.norms = norms;
  52                         this.weightValue = weight.GetValue();
  53
  54                         for (int i = 0; i < SCORE_CACHE_SIZE; i++)
  55                                 scoreCache[i] = GetSimilarity().Tf(i) * weightValue;
  56                 }
  57
  58         public override void  Score(HitCollector hc)
  59         {
  60             Next();
  61             Score(hc, System.Int32.MaxValue);
  62         }
  63
  64         protected internal override bool Score(HitCollector c, int end)
  65         {
  66             Similarity similarity = GetSimilarity(); // cache sim in local
  67             float[] normDecoder = Similarity.GetNormDecoder();
  68             while (doc < end)
  69             {
  70                 // for docs in window
  71                 int f = freqs[pointer];
  72                 float score = f < SCORE_CACHE_SIZE?scoreCache[f]:similarity.Tf(f) * weightValue; // cache miss
  73
  74                 score *= normDecoder[norms[doc] & 0xFF]; // normalize for field
  75
  76                 c.Collect(doc, score); // collect score
  77
  78                 if (++pointer >= pointerMax)
  79                 {
  80                     pointerMax = termDocs.Read(docs, freqs); // refill buffers
  81                     if (pointerMax != 0)
  82                     {
  83                         pointer = 0;
  84                     }
  85                     else
  86                     {
  87                         termDocs.Close(); // close stream
  88                         doc = System.Int32.MaxValue; // set to sentinel value
  89                         return false;
  90                     }
  91                 }
  92                 doc = docs[pointer];
  93             }
  94             return true;
  95         }
  96
  97         /// <summary>Returns the current document number matching the query.
  98         /// Initially invalid, until {@link #next()} is called the first time.
  99         /// </summary>
 100         public override int Doc()
 101                 {
 102                         return doc;
 103                 }
 104
 105         /// <summary>Advances to the next document matching the query.
 106         /// <br>The iterator over the matching documents is buffered using
 107         /// {@link TermDocs#Read(int[],int[])}.
 108         /// </summary>
 109         /// <returns> true iff there is another document matching the query.
 110         /// </returns>
 111         public override bool Next()
 112                 {
 113                         pointer++;
 114                         if (pointer >= pointerMax)
 115                         {
 116                                 pointerMax = termDocs.Read(docs, freqs); // refill buffer
 117                                 if (pointerMax != 0)
 118                                 {
 119                                         pointer = 0;
 120                                 }
 121                                 else
 122                                 {
 123                                         termDocs.Close(); // close stream
 124                                         doc = System.Int32.MaxValue; // set to sentinel value
 125                                         return false;
 126                                 }
 127                         }
 128                         doc = docs[pointer];
 129                         return true;
 130                 }
 131
 132                 public override float Score()
 133                 {
 134                         int f = freqs[pointer];
 135                         float raw = f < SCORE_CACHE_SIZE ? scoreCache[f] : GetSimilarity().Tf(f) * weightValue; // cache miss
 136
 137                         return raw * Similarity.DecodeNorm(norms[doc ]); // normalize for Field
 138                 }
 139
 140         /// <summary>Skips to the first match beyond the current whose document number is
 141         /// greater than or equal to a given target.
 142         /// <br>The implementation uses {@link TermDocs#SkipTo(int)}.
 143         /// </summary>
 144         /// <param name="target">The target document number.
 145         /// </param>
 146         /// <returns> true iff there is such a match.
 147         /// </returns>
 148         public override bool SkipTo(int target)
 149                 {
 150                         // first scan in cache
 151                         for (pointer++; pointer < pointerMax; pointer++)
 152                         {
 153                                 if (docs[pointer] >= target)
 154                                 {
 155                                         doc = docs[pointer];
 156                                         return true;
 157                                 }
 158                         }
 159
 160                         // not found in cache, seek underlying stream
 161                         bool result = termDocs.SkipTo(target);
 162                         if (result)
 163                         {
 164                                 pointerMax = 1;
 165                                 pointer = 0;
 166                                 docs[pointer] = doc = termDocs.Doc();
 167                                 freqs[pointer] = termDocs.Freq();
 168                         }
 169                         else
 170                         {
 171                                 doc = System.Int32.MaxValue;
 172                         }
 173                         return result;
 174                 }
 175
 176         /// <summary>Returns an explanation of the score for a document.
 177         /// <br>When this method is used, the {@link #next()} method
 178         /// and the {@link #Score(HitCollector)} method should not be used.
 179         /// </summary>
 180         /// <param name="doc">The document number for the explanation.
 181         /// </param>
 182         /// <todo>  Modify to make use of {@link TermDocs#SkipTo(int)}. </todo>
 183         public override Explanation Explain(int doc)
 184                 {
 185                         TermQuery query = (TermQuery) weight.GetQuery();
 186                         Explanation tfExplanation = new Explanation();
 187                         int tf = 0;
 188                         while (pointer < pointerMax)
 189                         {
 190                                 if (docs[pointer] == doc)
 191                                         tf = freqs[pointer];
 192                                 pointer++;
 193                         }
 194                         if (tf == 0)
 195                         {
 196                                 while (termDocs.Next())
 197                                 {
 198                                         if (termDocs.Doc() == doc)
 199                                         {
 200                                                 tf = termDocs.Freq();
 201                                         }
 202                                 }
 203                         }
 204                         termDocs.Close();
 205                         tfExplanation.SetValue(GetSimilarity().Tf(tf));
 206                         tfExplanation.SetDescription("tf(termFreq(" + query.GetTerm() + ")=" + tf + ")");
 207
 208                         return tfExplanation;
 209                 }
 210
 211                 public override System.String ToString()
 212                 {
 213                         return "scorer(" + weight + ")";
 214                 }
 215         }
 216 }