beagled/Lucene.Net/Search/MatchAllDocsQuery.cs

   1 /*
   2  * Copyright 2005 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 using ToStringUtils = Lucene.Net.Util.ToStringUtils;
  20
  21 namespace Lucene.Net.Search
  22 {
  23
  24         /// <summary> A query that matches all documents.
  25         ///
  26         /// </summary>
  27         /// <author>  John Wang
  28         /// </author>
  29         [Serializable]
  30         public class MatchAllDocsQuery : Query
  31         {
  32
  33                 public MatchAllDocsQuery()
  34                 {
  35                 }
  36
  37                 private class MatchAllScorer:Scorer
  38                 {
  39                         private void  InitBlock(MatchAllDocsQuery enclosingInstance)
  40                         {
  41                                 this.enclosingInstance = enclosingInstance;
  42                         }
  43                         private MatchAllDocsQuery enclosingInstance;
  44                         public MatchAllDocsQuery Enclosing_Instance
  45                         {
  46                                 get
  47                                 {
  48                                         return enclosingInstance;
  49                                 }
  50
  51                         }
  52
  53                         internal IndexReader reader;
  54                         internal int count;
  55                         internal int maxDoc;
  56
  57                         internal MatchAllScorer(MatchAllDocsQuery enclosingInstance, IndexReader reader, Similarity similarity) : base(similarity)
  58                         {
  59                                 InitBlock(enclosingInstance);
  60                                 this.reader = reader;
  61                                 count = - 1;
  62                                 maxDoc = reader.MaxDoc();
  63                         }
  64
  65                         public override int Doc()
  66                         {
  67                                 return count;
  68                         }
  69
  70                         public override Explanation Explain(int doc)
  71                         {
  72                                 Explanation explanation = new Explanation();
  73                                 explanation.SetValue(1.0f);
  74                                 explanation.SetDescription("MatchAllDocsQuery");
  75                                 return explanation;
  76                         }
  77
  78                         public override bool Next()
  79                         {
  80                                 while (count < (maxDoc - 1))
  81                                 {
  82                                         count++;
  83                                         if (!reader.IsDeleted(count))
  84                                         {
  85                                                 return true;
  86                                         }
  87                                 }
  88                                 return false;
  89                         }
  90
  91                         public override float Score()
  92                         {
  93                                 return 1.0f;
  94                         }
  95
  96                         public override bool SkipTo(int target)
  97                         {
  98                                 count = target - 1;
  99                                 return Next();
 100                         }
 101                 }
 102
 103                 [Serializable]
 104                 private class MatchAllDocsWeight : Weight
 105                 {
 106                         private void  InitBlock(MatchAllDocsQuery enclosingInstance)
 107                         {
 108                                 this.enclosingInstance = enclosingInstance;
 109                         }
 110                         private MatchAllDocsQuery enclosingInstance;
 111                         public MatchAllDocsQuery Enclosing_Instance
 112                         {
 113                                 get
 114                                 {
 115                                         return enclosingInstance;
 116                                 }
 117
 118                         }
 119                         private Searcher searcher;
 120
 121                         public MatchAllDocsWeight(MatchAllDocsQuery enclosingInstance, Searcher searcher)
 122                         {
 123                                 InitBlock(enclosingInstance);
 124                                 this.searcher = searcher;
 125                         }
 126
 127                         public override System.String ToString()
 128                         {
 129                                 return "weight(" + Enclosing_Instance + ")";
 130                         }
 131
 132                         public virtual Query GetQuery()
 133                         {
 134                                 return Enclosing_Instance;
 135                         }
 136
 137                         public virtual float GetValue()
 138                         {
 139                                 return 1.0f;
 140                         }
 141
 142                         public virtual float SumOfSquaredWeights()
 143                         {
 144                                 return 1.0f;
 145                         }
 146
 147                         public virtual void  Normalize(float queryNorm)
 148                         {
 149                         }
 150
 151                         public virtual Scorer Scorer(IndexReader reader)
 152                         {
 153                                 return new MatchAllScorer(enclosingInstance, reader, Enclosing_Instance.GetSimilarity(searcher));
 154                         }
 155
 156                         public virtual Explanation Explain(IndexReader reader, int doc)
 157                         {
 158                                 // explain query weight
 159                                 Explanation queryExpl = new Explanation();
 160                                 queryExpl.SetDescription("MatchAllDocsQuery:");
 161
 162                                 Explanation boostExpl = new Explanation(Enclosing_Instance.GetBoost(), "boost");
 163                                 if (Enclosing_Instance.GetBoost() != 1.0f)
 164                                         queryExpl.AddDetail(boostExpl);
 165                                 queryExpl.SetValue(boostExpl.GetValue());
 166
 167                                 return queryExpl;
 168                         }
 169                 }
 170
 171                 protected internal override Weight CreateWeight(Searcher searcher)
 172                 {
 173                         return new MatchAllDocsWeight(this, searcher);
 174                 }
 175
 176                 public override System.String ToString(System.String field)
 177                 {
 178                         System.Text.StringBuilder buffer = new System.Text.StringBuilder();
 179                         buffer.Append("MatchAllDocsQuery");
 180                         buffer.Append(ToStringUtils.Boost(GetBoost()));
 181                         return buffer.ToString();
 182                 }
 183
 184                 public  override bool Equals(System.Object o)
 185                 {
 186                         if (!(o is MatchAllDocsQuery))
 187                                 return false;
 188                         MatchAllDocsQuery other = (MatchAllDocsQuery) o;
 189                         return this.GetBoost() == other.GetBoost();
 190                 }
 191
 192                 public override int GetHashCode()
 193                 {
 194                         return BitConverter.ToInt32(BitConverter.GetBytes(GetBoost()), 0);
 195                 }
 196         }
 197 }