beagled/Lucene.Net/Search/RangeFilter.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 using Term = Lucene.Net.Index.Term;
  20 using TermDocs = Lucene.Net.Index.TermDocs;
  21 using TermEnum = Lucene.Net.Index.TermEnum;
  22
  23 namespace Lucene.Net.Search
  24 {
  25
  26         /// <summary> A Filter that restricts search results to a range of values in a given
  27         /// field.
  28         ///
  29         /// <p>
  30         /// This code borrows heavily from {@link RangeQuery}, but is implemented as a Filter
  31         /// (much like {@link DateFilter}).
  32         /// </p>
  33         /// </summary>
  34         [Serializable]
  35         public class RangeFilter : Filter
  36         {
  37
  38                 private System.String fieldName;
  39                 private System.String lowerTerm;
  40                 private System.String upperTerm;
  41                 private bool includeLower;
  42                 private bool includeUpper;
  43
  44                 /// <param name="fieldName">The field this range applies to
  45                 /// </param>
  46                 /// <param name="lowerTerm">The lower bound on this range
  47                 /// </param>
  48                 /// <param name="upperTerm">The upper bound on this range
  49                 /// </param>
  50                 /// <param name="includeLower">Does this range include the lower bound?
  51                 /// </param>
  52                 /// <param name="includeUpper">Does this range include the upper bound?
  53                 /// </param>
  54                 /// <throws>  IllegalArgumentException if both terms are null or if </throws>
  55                 /// <summary>  lowerTerm is null and includeLower is true (similar for upperTerm
  56                 /// and includeUpper)
  57                 /// </summary>
  58                 public RangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper)
  59                 {
  60                         this.fieldName = fieldName;
  61                         this.lowerTerm = lowerTerm;
  62                         this.upperTerm = upperTerm;
  63                         this.includeLower = includeLower;
  64                         this.includeUpper = includeUpper;
  65
  66                         if (null == lowerTerm && null == upperTerm)
  67                         {
  68                                 throw new System.ArgumentException("At least one value must be non-null");
  69                         }
  70                         if (includeLower && null == lowerTerm)
  71                         {
  72                                 throw new System.ArgumentException("The lower bound must be non-null to be inclusive");
  73                         }
  74                         if (includeUpper && null == upperTerm)
  75                         {
  76                                 throw new System.ArgumentException("The upper bound must be non-null to be inclusive");
  77                         }
  78                 }
  79
  80                 /// <summary> Constructs a filter for field <code>fieldName</code> matching
  81                 /// less than or equal to <code>upperTerm</code>.
  82                 /// </summary>
  83                 public static RangeFilter Less(System.String fieldName, System.String upperTerm)
  84                 {
  85                         return new RangeFilter(fieldName, null, upperTerm, false, true);
  86                 }
  87
  88                 /// <summary> Constructs a filter for field <code>fieldName</code> matching
  89                 /// greater than or equal to <code>lowerTerm</code>.
  90                 /// </summary>
  91                 public static RangeFilter More(System.String fieldName, System.String lowerTerm)
  92                 {
  93                         return new RangeFilter(fieldName, lowerTerm, null, true, false);
  94                 }
  95
  96                 /// <summary> Returns a BitSet with true for documents which should be
  97                 /// permitted in search results, and false for those that should
  98                 /// not.
  99                 /// </summary>
 100                 public override System.Collections.BitArray Bits(IndexReader reader)
 101                 {
 102                         System.Collections.BitArray bits = new System.Collections.BitArray((reader.MaxDoc() % 64 == 0?reader.MaxDoc() / 64:reader.MaxDoc() / 64 + 1) * 64);
 103                         TermEnum enumerator = (null != lowerTerm?reader.Terms(new Term(fieldName, lowerTerm)):reader.Terms(new Term(fieldName, "")));
 104
 105                         try
 106                         {
 107
 108                                 if (enumerator.Term() == null)
 109                                 {
 110                                         return bits;
 111                                 }
 112
 113                                 bool checkLower = false;
 114                                 if (!includeLower)
 115                                     // make adjustments to set to exclusive
 116                                         checkLower = true;
 117
 118                                 TermDocs termDocs = reader.TermDocs();
 119                                 try
 120                                 {
 121
 122                                         do
 123                                         {
 124                                                 Term term = enumerator.Term();
 125                                                 if (term != null && term.Field().Equals(fieldName))
 126                                                 {
 127                                                         if (!checkLower || null == lowerTerm || String.CompareOrdinal(term.Text(), lowerTerm) > 0)
 128                                                         {
 129                                                                 checkLower = false;
 130                                                                 if (upperTerm != null)
 131                                                                 {
 132                                                                         int compare = String.CompareOrdinal(upperTerm, term.Text());
 133                                                                         /* if beyond the upper term, or is exclusive and
 134                                                                         * this is equal to the upper term, break out */
 135                                                                         if ((compare < 0) || (!includeUpper && compare == 0))
 136                                                                         {
 137                                                                                 break;
 138                                                                         }
 139                                                                 }
 140                                                                 /* we have a good term, find the docs */
 141
 142                                                                 termDocs.Seek(enumerator.Term());
 143                                                                 while (termDocs.Next())
 144                                                                 {
 145                                                                         bits.Set(termDocs.Doc(), true);
 146                                                                 }
 147                                                         }
 148                                                 }
 149                                                 else
 150                                                 {
 151                                                         break;
 152                                                 }
 153                                         }
 154                                         while (enumerator.Next());
 155                                 }
 156                                 finally
 157                                 {
 158                                         termDocs.Close();
 159                                 }
 160                         }
 161                         finally
 162                         {
 163                                 enumerator.Close();
 164                         }
 165
 166                         return bits;
 167                 }
 168
 169                 public override System.String ToString()
 170                 {
 171                         System.Text.StringBuilder buffer = new System.Text.StringBuilder();
 172                         buffer.Append(fieldName);
 173                         buffer.Append(":");
 174                         buffer.Append(includeLower?"[":"{");
 175                         if (null != lowerTerm)
 176                         {
 177                                 buffer.Append(lowerTerm);
 178                         }
 179                         buffer.Append("-");
 180                         if (null != upperTerm)
 181                         {
 182                                 buffer.Append(upperTerm);
 183                         }
 184                         buffer.Append(includeUpper ? "]" : "}");
 185                         return buffer.ToString();
 186                 }
 187
 188                 /// <summary>Returns true if <code>o</code> is equal to this. </summary>
 189                 public  override bool Equals(System.Object o)
 190                 {
 191                         if (this == o)
 192                                 return true;
 193                         if (!(o is RangeFilter))
 194                                 return false;
 195                         RangeFilter other = (RangeFilter) o;
 196
 197                         if (!this.fieldName.Equals(other.fieldName) || this.includeLower != other.includeLower || this.includeUpper != other.includeUpper)
 198                         {
 199                                 return false;
 200                         }
 201                         if (this.lowerTerm != null ? !this.lowerTerm.Equals(other.lowerTerm) : other.lowerTerm != null)
 202                                 return false;
 203                         if (this.upperTerm != null ? !this.upperTerm.Equals(other.upperTerm) : other.upperTerm != null)
 204                                 return false;
 205                         return true;
 206                 }
 207
 208                 /// <summary>Returns a hash code value for this object.</summary>
 209                 public override int GetHashCode()
 210                 {
 211                         int h = fieldName.GetHashCode();
 212                         h ^= (lowerTerm != null ? lowerTerm.GetHashCode() : unchecked((int) 0xB6ECE882));           // {{Aroush-1.9}} is this OK?!
 213                         h = (h << 1) | (SupportClass.Number.URShift(h, 31)); // rotate to distinguish lower from upper
 214                         h ^= (upperTerm != null ? (upperTerm.GetHashCode()) : unchecked((int) 0x91BEC2C2));         // {{Aroush-1.9}} is this OK?!
 215                         h ^= (includeLower ? unchecked((int) 0xD484B933) : 0) ^ (includeUpper ? 0x6AE423AC : 0);    // {{Aroush-1.9}} is this OK?!
 216                         return h;
 217                 }
 218         }
 219 }