mcs/tools/monkeydoc/Lucene.Net/Lucene.Net/Search/ScoreCachingWrappingScorer.cs

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * the License.  You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 using System;
  19
  20 namespace Mono.Lucene.Net.Search
  21 {
  22
  23         /// <summary> A {@link Scorer} which wraps another scorer and caches the score of the
  24         /// current document. Successive calls to {@link #Score()} will return the same
  25         /// result and will not invoke the wrapped Scorer's score() method, unless the
  26         /// current document has changed.<br/>
  27         /// This class might be useful due to the changes done to the {@link Collector}
  28         /// interface, in which the score is not computed for a document by default, only
  29         /// if the collector requests it. Some collectors may need to use the score in
  30         /// several places, however all they have in hand is a {@link Scorer} object, and
  31         /// might end up computing the score of a document more than once.
  32         /// </summary>
  33         public class ScoreCachingWrappingScorer:Scorer
  34         {
  35
  36                 private Scorer scorer;
  37                 private int curDoc = - 1;
  38                 private float curScore;
  39
  40                 /// <summary>Creates a new instance by wrapping the given scorer. </summary>
  41                 public ScoreCachingWrappingScorer(Scorer scorer):base(scorer.GetSimilarity())
  42                 {
  43                         this.scorer = scorer;
  44                 }
  45
  46                 public /*protected internal*/ override bool Score(Collector collector, int max, int firstDocID)
  47                 {
  48                         return scorer.Score(collector, max, firstDocID);
  49                 }
  50
  51                 public override Similarity GetSimilarity()
  52                 {
  53                         return scorer.GetSimilarity();
  54                 }
  55
  56                 public override Explanation Explain(int doc)
  57                 {
  58                         return scorer.Explain(doc);
  59                 }
  60
  61                 public override float Score()
  62                 {
  63                         int doc = scorer.DocID();
  64                         if (doc != curDoc)
  65                         {
  66                                 curScore = scorer.Score();
  67                                 curDoc = doc;
  68                         }
  69
  70                         return curScore;
  71                 }
  72
  73                 /// <deprecated> use {@link #DocID()} instead.
  74                 /// </deprecated>
  75         [Obsolete("use DocID() instead.")]
  76                 public override int Doc()
  77                 {
  78                         return scorer.Doc();
  79                 }
  80
  81                 public override int DocID()
  82                 {
  83                         return scorer.DocID();
  84                 }
  85
  86                 /// <deprecated> use {@link #NextDoc()} instead.
  87                 /// </deprecated>
  88         [Obsolete("use NextDoc() instead.")]
  89                 public override bool Next()
  90                 {
  91                         return scorer.Next();
  92                 }
  93
  94                 public override int NextDoc()
  95                 {
  96                         return scorer.NextDoc();
  97                 }
  98
  99                 public override void  Score(Collector collector)
 100                 {
 101                         scorer.Score(collector);
 102                 }
 103
 104                 /// <deprecated> use {@link #Advance(int)} instead.
 105                 /// </deprecated>
 106         [Obsolete("use Advance(int) instead.")]
 107                 public override bool SkipTo(int target)
 108                 {
 109                         return scorer.SkipTo(target);
 110                 }
 111
 112                 public override int Advance(int target)
 113                 {
 114                         return scorer.Advance(target);
 115                 }
 116         }
 117 }