beagled/Lucene.Net/Search/ConstantScoreQuery.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
  17 using System;
  18 using IndexReader = Lucene.Net.Index.IndexReader;
  19
  20 namespace Lucene.Net.Search
  21 {
  22
  23         /// <summary> A query that wraps a filter and simply returns a constant score equal to the
  24         /// query boost for every document in the filter.
  25         ///
  26         /// </summary>
  27         /// <author>  yonik
  28         /// </author>
  29         /// <version>  $Id: ConstantScoreQuery.cs,v 1.2 2006/10/02 17:09:02 joeshaw Exp $
  30         /// </version>
  31         [Serializable]
  32         public class ConstantScoreQuery : Query
  33         {
  34                 protected internal Filter filter;
  35
  36                 public ConstantScoreQuery(Filter filter)
  37                 {
  38                         this.filter = filter;
  39                 }
  40
  41                 public override Query Rewrite(IndexReader reader)
  42                 {
  43                         return this;
  44                 }
  45
  46                 [Serializable]
  47                 protected internal class ConstantWeight : Weight
  48                 {
  49                         private void  InitBlock(ConstantScoreQuery enclosingInstance)
  50                         {
  51                                 this.enclosingInstance = enclosingInstance;
  52                         }
  53                         private ConstantScoreQuery enclosingInstance;
  54                         public ConstantScoreQuery Enclosing_Instance
  55                         {
  56                                 get
  57                                 {
  58                                         return enclosingInstance;
  59                                 }
  60
  61                         }
  62                         private Searcher searcher;
  63                         private float queryNorm;
  64                         private float queryWeight;
  65
  66                         public ConstantWeight(ConstantScoreQuery enclosingInstance, Searcher searcher)
  67                         {
  68                                 InitBlock(enclosingInstance);
  69                                 this.searcher = searcher;
  70                         }
  71
  72                         public virtual Query GetQuery()
  73                         {
  74                                 return Enclosing_Instance;
  75                         }
  76
  77                         public virtual float GetValue()
  78                         {
  79                                 return queryWeight;
  80                         }
  81
  82                         public virtual float SumOfSquaredWeights()
  83                         {
  84                                 queryWeight = Enclosing_Instance.GetBoost();
  85                                 return queryWeight * queryWeight;
  86                         }
  87
  88                         public virtual void  Normalize(float norm)
  89                         {
  90                                 this.queryNorm = norm;
  91                                 queryWeight *= this.queryNorm;
  92                         }
  93
  94                         public virtual Scorer Scorer(IndexReader reader)
  95                         {
  96                                 return new ConstantScorer(enclosingInstance, Enclosing_Instance.GetSimilarity(searcher), reader, this);
  97                         }
  98
  99                         public virtual Explanation Explain(IndexReader reader, int doc)
 100                         {
 101
 102                                 ConstantScorer cs = (ConstantScorer) Scorer(reader);
 103                                 bool exists = cs.bits.Get(doc);
 104
 105                                 Explanation result = new Explanation();
 106
 107                                 if (exists)
 108                                 {
 109                                         result.SetDescription("ConstantScoreQuery(" + Enclosing_Instance.filter + "), product of:");
 110                                         result.SetValue(queryWeight);
 111                                         result.AddDetail(new Explanation(Enclosing_Instance.GetBoost(), "boost"));
 112                                         result.AddDetail(new Explanation(queryNorm, "queryNorm"));
 113                                 }
 114                                 else
 115                                 {
 116                                         result.SetDescription("ConstantScoreQuery(" + Enclosing_Instance.filter + ") doesn't match id " + doc);
 117                                         result.SetValue(0);
 118                                 }
 119                                 return result;
 120                         }
 121                 }
 122
 123                 protected internal class ConstantScorer : Scorer
 124                 {
 125                         private void  InitBlock(ConstantScoreQuery enclosingInstance)
 126                         {
 127                                 this.enclosingInstance = enclosingInstance;
 128                         }
 129                         private ConstantScoreQuery enclosingInstance;
 130                         public ConstantScoreQuery Enclosing_Instance
 131                         {
 132                                 get
 133                                 {
 134                                         return enclosingInstance;
 135                                 }
 136
 137                         }
 138                         internal System.Collections.BitArray bits;
 139                         internal float theScore;
 140                         internal int doc = - 1;
 141
 142                         public ConstantScorer(ConstantScoreQuery enclosingInstance, Similarity similarity, IndexReader reader, Weight w) : base(similarity)
 143                         {
 144                                 InitBlock(enclosingInstance);
 145                                 theScore = w.GetValue();
 146                                 bits = Enclosing_Instance.filter.Bits(reader);
 147                         }
 148
 149                         public override bool Next()
 150                         {
 151                                 doc = SupportClass.Number.NextSetBit(bits, doc + 1);
 152                                 return doc >= 0;
 153                         }
 154
 155                         public override int Doc()
 156                         {
 157                                 return doc;
 158                         }
 159
 160                         public override float Score()
 161                         {
 162                                 return theScore;
 163                         }
 164
 165                         public override bool SkipTo(int target)
 166                         {
 167                                 doc = SupportClass.Number.NextSetBit(bits, target); // requires JDK 1.4
 168                                 return doc >= 0;
 169                         }
 170
 171                         public override Explanation Explain(int doc)
 172                         {
 173                                 throw new System.NotSupportedException();
 174                         }
 175                 }
 176
 177
 178                 protected internal override Weight CreateWeight(Searcher searcher)
 179                 {
 180                         return new ConstantScoreQuery.ConstantWeight(this, searcher);
 181                 }
 182
 183
 184                 /// <summary>Prints a user-readable version of this query. </summary>
 185                 public override System.String ToString(System.String field)
 186                 {
 187                         return "ConstantScore(" + filter.ToString() + (GetBoost() == 1.0 ? ")" : "^" + GetBoost());
 188                 }
 189
 190                 /// <summary>Returns true if <code>o</code> is equal to this. </summary>
 191                 public  override bool Equals(System.Object o)
 192                 {
 193                         if (this == o)
 194                                 return true;
 195                         if (!(o is ConstantScoreQuery))
 196                                 return false;
 197                         ConstantScoreQuery other = (ConstantScoreQuery) o;
 198                         return this.GetBoost() == other.GetBoost() && filter.Equals(other.filter);
 199                 }
 200
 201                 /// <summary>Returns a hash code value for this object. </summary>
 202                 public override int GetHashCode()
 203                 {
 204                         // Simple add is OK since no existing filter hashcode has a float component.
 205                         return filter.GetHashCode() + BitConverter.ToInt32(BitConverter.GetBytes(GetBoost()), 0);
 206                 }
 207
 208         override public System.Object Clone()
 209                 {
 210             // {{Aroush-1.9}} is this all that we need to clone?!
 211             ConstantScoreQuery clone = (ConstantScoreQuery) base.Clone();
 212             clone.filter = (Filter) this.filter;
 213             return clone;
 214         }
 215         }
 216 }