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 using System;
  17 using IndexReader = Lucene.Net.Index.IndexReader;
  18 using Term = Lucene.Net.Index.Term;
  19 using TermPositions = Lucene.Net.Index.TermPositions;
  20 namespace Lucene.Net.Search.Spans
  21 {
  22
  23         /// <summary>Matches spans containing a term. </summary>
  24         [Serializable]
  25         public class SpanTermQuery:SpanQuery
  26         {
  27                 private class AnonymousClassSpans : Spans
  28                 {
  29                         public AnonymousClassSpans(Lucene.Net.Index.IndexReader reader, SpanTermQuery enclosingInstance)
  30                         {
  31                                 InitBlock(reader, enclosingInstance);
  32                         }
  33                         private void  InitBlock(Lucene.Net.Index.IndexReader reader, SpanTermQuery enclosingInstance)
  34                         {
  35                                 this.reader = reader;
  36                                 this.enclosingInstance = enclosingInstance;
  37                                 positions = reader.TermPositions(Enclosing_Instance.term);
  38                         }
  39                         private Lucene.Net.Index.IndexReader reader;
  40                         private SpanTermQuery enclosingInstance;
  41                         public SpanTermQuery Enclosing_Instance
  42                         {
  43                                 get
  44                                 {
  45                                         return enclosingInstance;
  46                                 }
  47
  48                         }
  49                         private TermPositions positions;
  50
  51                         private int doc = - 1;
  52                         private int freq;
  53                         private int count;
  54                         private int position;
  55
  56                         public virtual bool Next()
  57                         {
  58                                 if (count == freq)
  59                                 {
  60                                         if (!positions.Next())
  61                                         {
  62                                                 doc = System.Int32.MaxValue;
  63                                                 return false;
  64                                         }
  65                                         doc = positions.Doc();
  66                                         freq = positions.Freq();
  67                                         count = 0;
  68                                 }
  69                                 position = positions.NextPosition();
  70                                 count++;
  71                                 return true;
  72                         }
  73
  74                         public virtual bool SkipTo(int target)
  75                         {
  76                                 if (!positions.SkipTo(target))
  77                                 {
  78                                         doc = System.Int32.MaxValue;
  79                                         return false;
  80                                 }
  81
  82                                 doc = positions.Doc();
  83                                 freq = positions.Freq();
  84                                 count = 0;
  85
  86                                 position = positions.NextPosition();
  87                                 count++;
  88
  89                                 return true;
  90                         }
  91
  92                         public virtual int Doc()
  93                         {
  94                                 return doc;
  95                         }
  96                         public virtual int Start()
  97                         {
  98                                 return position;
  99                         }
 100                         public virtual int End()
 101                         {
 102                                 return position + 1;
 103                         }
 104
 105                         public override System.String ToString()
 106                         {
 107                                 return "spans(" + Enclosing_Instance.ToString() + ")@" + (doc == - 1?"START":((doc == System.Int32.MaxValue)?"END":doc + "-" + position));
 108                         }
 109                 }
 110                 private Term term;
 111
 112                 /// <summary>Construct a SpanTermQuery matching the named term's spans. </summary>
 113                 public SpanTermQuery(Term term)
 114                 {
 115                         this.term = term;
 116                 }
 117
 118                 /// <summary>Return the term whose spans are matched. </summary>
 119                 public virtual Term GetTerm()
 120                 {
 121                         return term;
 122                 }
 123
 124                 public override System.String GetField()
 125                 {
 126                         return term.Field();
 127                 }
 128
 129                 public override System.Collections.ICollection GetTerms()
 130                 {
 131                         System.Collections.ArrayList terms = new System.Collections.ArrayList();
 132             terms.Add(term);
 133                         return terms;
 134                 }
 135
 136                 public override System.String ToString(System.String field)
 137                 {
 138                         if (term.Field().Equals(field))
 139                                 return term.Text();
 140                         else
 141                         {
 142                                 return term.ToString();
 143                         }
 144                 }
 145
 146                 public override Spans GetSpans(IndexReader reader)
 147                 {
 148                         return new AnonymousClassSpans(reader, this);
 149                 }
 150         }
 151 }