FileDocCategorySizeDatePackage
TermScorer.javaAPI DocApache Lucene 1.96425Mon Feb 20 09:20:04 GMT 2006org.apache.lucene.search

TermScorer

public final class TermScorer extends Scorer
Expert: A Scorer for documents matching a Term.

Fields Summary
private Weight
weight
private TermDocs
termDocs
private byte[]
norms
private float
weightValue
private int
doc
private final int[]
docs
private final int[]
freqs
private int
pointer
private int
pointerMax
private static final int
SCORE_CACHE_SIZE
private float[]
scoreCache
Constructors Summary
TermScorer(Weight weight, TermDocs td, Similarity similarity, byte[] norms)
Construct a TermScorer.

param
weight The weight of the Term in the query.
param
td An iterator over the documents matching the Term.
param
similarity The Similarity implementation to be used for score computations.
param
norms The field norms of the document fields for the Term.


                                                   
       
               
    super(similarity);
    this.weight = weight;
    this.termDocs = td;
    this.norms = norms;
    this.weightValue = weight.getValue();

    for (int i = 0; i < SCORE_CACHE_SIZE; i++)
      scoreCache[i] = getSimilarity().tf(i) * weightValue;
Methods Summary
public intdoc()
Returns the current document number matching the query. Initially invalid, until {@link #next()} is called the first time.

 return doc;
public org.apache.lucene.search.Explanationexplain(int doc)
Returns an explanation of the score for a document.
When this method is used, the {@link #next()} method and the {@link #score(HitCollector)} method should not be used.

param
doc The document number for the explanation.
todo
Modify to make use of {@link TermDocs#skipTo(int)}.

    TermQuery query = (TermQuery)weight.getQuery();
    Explanation tfExplanation = new Explanation();
    int tf = 0;
    while (pointer < pointerMax) {
      if (docs[pointer] == doc)
        tf = freqs[pointer];
      pointer++;
    }
    if (tf == 0) {
      while (termDocs.next()) {
        if (termDocs.doc() == doc) {
          tf = termDocs.freq();
        }
      }
    }
    termDocs.close();
    tfExplanation.setValue(getSimilarity().tf(tf));
    tfExplanation.setDescription("tf(termFreq("+query.getTerm()+")="+tf+")");
    
    return tfExplanation;
public booleannext()
Advances to the next document matching the query.
The iterator over the matching documents is buffered using {@link TermDocs#read(int[],int[])}.

return
true iff there is another document matching the query.

    pointer++;
    if (pointer >= pointerMax) {
      pointerMax = termDocs.read(docs, freqs);    // refill buffer
      if (pointerMax != 0) {
        pointer = 0;
      } else {
        termDocs.close();                         // close stream
        doc = Integer.MAX_VALUE;                  // set to sentinel value
        return false;
      }
    } 
    doc = docs[pointer];
    return true;
public voidscore(org.apache.lucene.search.HitCollector hc)

    next();
    score(hc, Integer.MAX_VALUE);
protected booleanscore(org.apache.lucene.search.HitCollector c, int end)

    Similarity similarity = getSimilarity();      // cache sim in local
    float[] normDecoder = Similarity.getNormDecoder();
    while (doc < end) {                           // for docs in window
      int f = freqs[pointer];
      float score =                               // compute tf(f)*weight
        f < SCORE_CACHE_SIZE                      // check cache
         ? scoreCache[f]                          // cache hit
         : similarity.tf(f)*weightValue;          // cache miss

      score *= normDecoder[norms[doc] & 0xFF];    // normalize for field

      c.collect(doc, score);                      // collect score

      if (++pointer >= pointerMax) {
        pointerMax = termDocs.read(docs, freqs);  // refill buffers
        if (pointerMax != 0) {
          pointer = 0;
        } else {
          termDocs.close();                       // close stream
          doc = Integer.MAX_VALUE;                // set to sentinel value
          return false;
        }
      } 
      doc = docs[pointer];
    }
    return true;
public floatscore()

    int f = freqs[pointer];
    float raw =                                   // compute tf(f)*weight
      f < SCORE_CACHE_SIZE                        // check cache
      ? scoreCache[f]                             // cache hit
      : getSimilarity().tf(f)*weightValue;        // cache miss

    return raw * Similarity.decodeNorm(norms[doc]); // normalize for field
public booleanskipTo(int target)
Skips to the first match beyond the current whose document number is greater than or equal to a given target.
The implementation uses {@link TermDocs#skipTo(int)}.

param
target The target document number.
return
true iff there is such a match.

    // first scan in cache
    for (pointer++; pointer < pointerMax; pointer++) {
      if (docs[pointer] >= target) {
        doc = docs[pointer];
        return true;
      }
    }

    // not found in cache, seek underlying stream
    boolean result = termDocs.skipTo(target);
    if (result) {
      pointerMax = 1;
      pointer = 0;
      docs[pointer] = doc = termDocs.doc();
      freqs[pointer] = termDocs.freq();
    } else {
      doc = Integer.MAX_VALUE;
    }
    return result;
public java.lang.StringtoString()
Returns a string representation of this TermScorer.

 return "scorer(" + weight + ")";