beagled/Lucene.Net/Search/Spans/SpanTermQuery.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 TermPositions = Lucene.Net.Index.TermPositions;
  21 using ToStringUtils = Lucene.Net.Util.ToStringUtils;
  22
  23 namespace Lucene.Net.Search.Spans
  24 {
  25
  26         /// <summary>Matches spans containing a term. </summary>
  27         [Serializable]
  28         public class SpanTermQuery:SpanQuery
  29         {
  30                 private class AnonymousClassSpans : Spans
  31                 {
  32                         public AnonymousClassSpans(Lucene.Net.Index.IndexReader reader, SpanTermQuery enclosingInstance)
  33                         {
  34                                 InitBlock(reader, enclosingInstance);
  35                         }
  36                         private void  InitBlock(Lucene.Net.Index.IndexReader reader, SpanTermQuery enclosingInstance)
  37                         {
  38                                 this.reader = reader;
  39                                 this.enclosingInstance = enclosingInstance;
  40                                 positions = reader.TermPositions(Enclosing_Instance.term);
  41                         }
  42                         private Lucene.Net.Index.IndexReader reader;
  43                         private SpanTermQuery enclosingInstance;
  44                         public SpanTermQuery Enclosing_Instance
  45                         {
  46                                 get
  47                                 {
  48                                         return enclosingInstance;
  49                                 }
  50
  51                         }
  52                         private TermPositions positions;
  53
  54                         private int doc = - 1;
  55                         private int freq;
  56                         private int count;
  57                         private int position;
  58
  59                         public virtual bool Next()
  60                         {
  61                                 if (count == freq)
  62                                 {
  63                                         if (!positions.Next())
  64                                         {
  65                                                 doc = System.Int32.MaxValue;
  66                                                 return false;
  67                                         }
  68                                         doc = positions.Doc();
  69                                         freq = positions.Freq();
  70                                         count = 0;
  71                                 }
  72                                 position = positions.NextPosition();
  73                                 count++;
  74                                 return true;
  75                         }
  76
  77                         public virtual bool SkipTo(int target)
  78                         {
  79                                 // are we already at the correct position?
  80                                 if (doc >= target)
  81                                 {
  82                                         return true;
  83                                 }
  84
  85                                 if (!positions.SkipTo(target))
  86                                 {
  87                                         doc = System.Int32.MaxValue;
  88                                         return false;
  89                                 }
  90
  91                                 doc = positions.Doc();
  92                                 freq = positions.Freq();
  93                                 count = 0;
  94
  95                                 position = positions.NextPosition();
  96                                 count++;
  97
  98                                 return true;
  99                         }
 100
 101                         public virtual int Doc()
 102                         {
 103                                 return doc;
 104                         }
 105                         public virtual int Start()
 106                         {
 107                                 return position;
 108                         }
 109                         public virtual int End()
 110                         {
 111                                 return position + 1;
 112                         }
 113
 114                         public override System.String ToString()
 115                         {
 116                                 return "spans(" + Enclosing_Instance.ToString() + ")@" + (doc == - 1?"START":((doc == System.Int32.MaxValue)?"END":doc + "-" + position));
 117                         }
 118                 }
 119                 private Term term;
 120
 121                 /// <summary>Construct a SpanTermQuery matching the named term's spans. </summary>
 122                 public SpanTermQuery(Term term)
 123                 {
 124                         this.term = term;
 125                 }
 126
 127                 /// <summary>Return the term whose spans are matched. </summary>
 128                 public virtual Term GetTerm()
 129                 {
 130                         return term;
 131                 }
 132
 133                 public override System.String GetField()
 134                 {
 135                         return term.Field();
 136                 }
 137
 138                 public override System.Collections.ICollection GetTerms()
 139                 {
 140                         System.Collections.ArrayList terms = new System.Collections.ArrayList();
 141                         terms.Add(term);
 142                         return terms;
 143                 }
 144
 145                 public override System.String ToString(System.String field)
 146                 {
 147                         System.Text.StringBuilder buffer = new System.Text.StringBuilder();
 148                         if (term.Field().Equals(field))
 149                                 buffer.Append(term.Text());
 150                         else
 151                         {
 152                                 buffer.Append(term.ToString());
 153                         }
 154                         buffer.Append(ToStringUtils.Boost(GetBoost()));
 155                         return buffer.ToString();
 156                 }
 157
 158                 /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
 159                 public  override bool Equals(System.Object o)
 160                 {
 161                         if (!(o is SpanTermQuery))
 162                                 return false;
 163                         SpanTermQuery other = (SpanTermQuery) o;
 164                         return (this.GetBoost() == other.GetBoost()) && this.term.Equals(other.term);
 165                 }
 166
 167                 /// <summary>Returns a hash code value for this object.</summary>
 168                 public override int GetHashCode()
 169                 {
 170             return GetBoost().ToString().GetHashCode() ^ term.GetHashCode();    // {{Aroush-1.9}} Is this OK?
 171                 }
 172
 173                 public override Spans GetSpans(IndexReader reader)
 174                 {
 175                         return new AnonymousClassSpans(reader, this);
 176                 }
 177         }
 178 }