beagled/Lucene.Net/Search/FilteredQuery.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 IndexReader = Lucene.Net.Index.IndexReader;
  18 namespace Lucene.Net.Search
  19 {
  20
  21
  22         /// <summary> A query that applies a filter to the results of another query.
  23         ///
  24         /// <p>Note: the bits are retrieved from the filter each time this
  25         /// query is used in a search - use a CachingWrapperFilter to avoid
  26         /// regenerating the bits every time.
  27         ///
  28         /// <p>Created: Apr 20, 2004 8:58:29 AM
  29         ///
  30         /// </summary>
  31         /// <author>   Tim Jones
  32         /// </author>
  33         /// <since>   1.4
  34         /// </since>
  35         /// <version>  $Id: FilteredQuery.cs,v 1.1 2005/01/17 19:54:30 joeshaw Exp $
  36         /// </version>
  37         /// <seealso cref="CachingWrapperFilter">
  38         /// </seealso>
  39         [Serializable]
  40         public class FilteredQuery : Query
  41         {
  42                 [Serializable]
  43                 private class AnonymousClassWeight : Weight
  44                 {
  45                         public AnonymousClassWeight(Lucene.Net.Search.Weight weight, Lucene.Net.Search.Searcher searcher, FilteredQuery enclosingInstance)
  46                         {
  47                                 InitBlock(weight, searcher, enclosingInstance);
  48                         }
  49                         private class AnonymousClassScorer : Scorer
  50                         {
  51                                 private void  InitBlock(Lucene.Net.Search.Scorer scorer, System.Collections.BitArray bitset, AnonymousClassWeight enclosingInstance)
  52                                 {
  53                                         this.scorer = scorer;
  54                                         this.bitset = bitset;
  55                                         this.enclosingInstance = enclosingInstance;
  56                                 }
  57                                 private Lucene.Net.Search.Scorer scorer;
  58                                 private System.Collections.BitArray bitset;
  59                                 private AnonymousClassWeight enclosingInstance;
  60                                 public AnonymousClassWeight Enclosing_Instance
  61                                 {
  62                                         get
  63                                         {
  64                                                 return enclosingInstance;
  65                                         }
  66
  67                                 }
  68                                 internal AnonymousClassScorer(Lucene.Net.Search.Scorer scorer, System.Collections.BitArray bitset, AnonymousClassWeight enclosingInstance, Lucene.Net.Search.Similarity Param1):base(Param1)
  69                                 {
  70                                         InitBlock(scorer, bitset, enclosingInstance);
  71                                 }
  72
  73                                 // pass these methods through to the enclosed scorer
  74                                 public override bool Next()
  75                                 {
  76                                         return scorer.Next();
  77                                 }
  78                                 public override int Doc()
  79                                 {
  80                                         return scorer.Doc();
  81                                 }
  82                                 public override bool SkipTo(int i)
  83                                 {
  84                                         return scorer.SkipTo(i);
  85                                 }
  86
  87                                 // if the document has been filtered out, set score to 0.0
  88                                 public override float Score()
  89                                 {
  90                                         return (bitset.Get(scorer.Doc()))?scorer.Score():0.0f;
  91                                 }
  92
  93                                 // add an explanation about whether the document was filtered
  94                                 public override Explanation Explain(int i)
  95                                 {
  96                                         Explanation exp = scorer.Explain(i);
  97                                         if (bitset.Get(i))
  98                                                 exp.SetDescription("allowed by filter: " + exp.GetDescription());
  99                                         else
 100                                                 exp.SetDescription("removed by filter: " + exp.GetDescription());
 101                                         return exp;
 102                                 }
 103                         }
 104                         private void  InitBlock(Lucene.Net.Search.Weight weight, Lucene.Net.Search.Searcher searcher, FilteredQuery enclosingInstance)
 105                         {
 106                                 this.weight = weight;
 107                                 this.searcher = searcher;
 108                                 this.enclosingInstance = enclosingInstance;
 109                         }
 110                         private Lucene.Net.Search.Weight weight;
 111                         private Lucene.Net.Search.Searcher searcher;
 112                         private FilteredQuery enclosingInstance;
 113             virtual public float Value
 114             {
 115                 // pass these methods through to enclosed query's weight
 116
 117                 get
 118                 {
 119                     return weight.Value;
 120                 }
 121
 122             }
 123             virtual public Query Query
 124             {
 125                 // return this query
 126
 127                 get
 128                 {
 129                     return Enclosing_Instance;
 130                 }
 131
 132             }
 133             public FilteredQuery Enclosing_Instance
 134                         {
 135                                 get
 136                                 {
 137                                         return enclosingInstance;
 138                                 }
 139
 140                         }
 141                         public virtual float SumOfSquaredWeights()
 142                         {
 143                                 return weight.SumOfSquaredWeights();
 144                         }
 145                         public virtual void  Normalize(float v)
 146                         {
 147                                 weight.Normalize(v);
 148                         }
 149                         public virtual Explanation Explain(IndexReader ir, int i)
 150                         {
 151                                 return weight.Explain(ir, i);
 152                         }
 153
 154                         // return a scorer that overrides the enclosed query's score if
 155                         // the given hit has been filtered out.
 156                         public virtual Scorer Scorer(IndexReader indexReader)
 157                         {
 158                                 Scorer scorer = weight.Scorer(indexReader);
 159                                 System.Collections.BitArray bitset = Enclosing_Instance.filter.Bits(indexReader);
 160                                 return new AnonymousClassScorer(scorer, bitset, this, Enclosing_Instance.query.GetSimilarity(searcher));
 161                         }
 162                 }
 163
 164                 internal Query query;
 165                 internal Filter filter;
 166
 167                 /// <summary> Constructs a new query which applies a filter to the results of the original query.
 168                 /// Filter.bits() will be called every time this query is used in a search.
 169                 /// </summary>
 170                 /// <param name="query"> Query to be filtered, cannot be <code>null</code>.
 171                 /// </param>
 172                 /// <param name="filter">Filter to apply to query results, cannot be <code>null</code>.
 173                 /// </param>
 174                 public FilteredQuery(Query query, Filter filter)
 175                 {
 176                         this.query = query;
 177                         this.filter = filter;
 178                 }
 179
 180                 /// <summary> Returns a Weight that applies the filter to the enclosed query's Weight.
 181                 /// This is accomplished by overriding the Scorer returned by the Weight.
 182                 /// </summary>
 183                 protected internal override Weight CreateWeight(Searcher searcher)
 184                 {
 185                         Weight weight = query.CreateWeight(searcher);
 186                         return new AnonymousClassWeight(weight, searcher, this);
 187                 }
 188
 189                 /// <summary>Rewrites the wrapped query. </summary>
 190                 public override Query Rewrite(IndexReader reader)
 191                 {
 192                         Query rewritten = query.Rewrite(reader);
 193                         if (rewritten != query)
 194                         {
 195                                 FilteredQuery clone = (FilteredQuery) this.Clone();
 196                                 clone.query = rewritten;
 197                                 return clone;
 198                         }
 199                         else
 200                         {
 201                                 return this;
 202                         }
 203                 }
 204
 205                 public virtual Query GetQuery()
 206                 {
 207                         return query;
 208                 }
 209
 210                 /// <summary>Prints a user-readable version of this query. </summary>
 211                 public override System.String ToString(System.String s)
 212                 {
 213                         return "filtered(" + query.ToString(s) + ")->" + filter;
 214                 }
 215
 216                 /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
 217                 public  override bool Equals(System.Object o)
 218                 {
 219                         if (o is FilteredQuery)
 220                         {
 221                                 FilteredQuery fq = (FilteredQuery) o;
 222                                 return (query.Equals(fq.query) && filter.Equals(fq.filter));
 223                         }
 224                         return false;
 225                 }
 226
 227                 /// <summary>Returns a hash code value for this object. </summary>
 228                 public override int GetHashCode()
 229                 {
 230                         return query.GetHashCode() ^ filter.GetHashCode();
 231                 }
 232         }
 233 }