beagled/Lucene.Net/Search/Spans/SpanNotQuery.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.Spans
  19 {
  20
  21         /// <summary>Removes matches which overlap with another SpanQuery. </summary>
  22         [Serializable]
  23         public class SpanNotQuery:SpanQuery
  24         {
  25                 private class AnonymousClassSpans : Spans
  26                 {
  27                         public AnonymousClassSpans(Lucene.Net.Index.IndexReader reader, SpanNotQuery enclosingInstance)
  28                         {
  29                                 InitBlock(reader, enclosingInstance);
  30                         }
  31                         private void  InitBlock(Lucene.Net.Index.IndexReader reader, SpanNotQuery enclosingInstance)
  32                         {
  33                                 this.reader = reader;
  34                                 this.enclosingInstance = enclosingInstance;
  35                                 includeSpans = Enclosing_Instance.include.GetSpans(reader);
  36                                 excludeSpans = Enclosing_Instance.exclude.GetSpans(reader);
  37                         }
  38                         private Lucene.Net.Index.IndexReader reader;
  39                         private SpanNotQuery enclosingInstance;
  40                         public SpanNotQuery Enclosing_Instance
  41                         {
  42                                 get
  43                                 {
  44                                         return enclosingInstance;
  45                                 }
  46
  47                         }
  48                         private Spans includeSpans;
  49                         private bool moreInclude = true;
  50
  51                         private Spans excludeSpans;
  52                         private bool moreExclude = true;
  53
  54                         public virtual bool Next()
  55                         {
  56                                 if (moreInclude)
  57                                 // move to next include
  58                                         moreInclude = includeSpans.Next();
  59
  60                                 while (moreInclude && moreExclude)
  61                                 {
  62
  63                                         if (includeSpans.Doc() > excludeSpans.Doc())
  64                                         // skip exclude
  65                                                 moreExclude = excludeSpans.SkipTo(includeSpans.Doc());
  66
  67                                         while (moreExclude && includeSpans.Doc() == excludeSpans.Doc() && excludeSpans.End() <= includeSpans.Start())
  68                                         {
  69                                                 moreExclude = excludeSpans.Next(); // increment exclude
  70                                         }
  71
  72                                         if (!moreExclude || includeSpans.Doc() != excludeSpans.Doc() || includeSpans.End() <= excludeSpans.Start())
  73                                                 break; // we found a match
  74
  75                                         moreInclude = includeSpans.Next(); // intersected: keep scanning
  76                                 }
  77                                 return moreInclude;
  78                         }
  79
  80                         public virtual bool SkipTo(int target)
  81                         {
  82                                 if (moreInclude)
  83                                 // skip include
  84                                         moreInclude = includeSpans.SkipTo(target);
  85
  86                                 if (!moreInclude)
  87                                         return false;
  88
  89                                 if (moreExclude && includeSpans.Doc() > excludeSpans.Doc())
  90                                         moreExclude = excludeSpans.SkipTo(includeSpans.Doc());
  91
  92                                 while (moreExclude && includeSpans.Doc() == excludeSpans.Doc() && excludeSpans.End() <= includeSpans.Start())
  93                                 {
  94                                         moreExclude = excludeSpans.Next(); // increment exclude
  95                                 }
  96
  97                                 if (!moreExclude || includeSpans.Doc() != excludeSpans.Doc() || includeSpans.End() <= excludeSpans.Start())
  98                                         return true; // we found a match
  99
 100                                 return Next(); // scan to next match
 101                         }
 102
 103                         public virtual int Doc()
 104                         {
 105                                 return includeSpans.Doc();
 106                         }
 107                         public virtual int Start()
 108                         {
 109                                 return includeSpans.Start();
 110                         }
 111                         public virtual int End()
 112                         {
 113                                 return includeSpans.End();
 114                         }
 115
 116                         public override System.String ToString()
 117                         {
 118                                 return "spans(" + Enclosing_Instance.ToString() + ")";
 119                         }
 120                 }
 121                 private SpanQuery include;
 122                 private SpanQuery exclude;
 123
 124                 /// <summary>Construct a SpanNotQuery matching spans from <code>include</code> which
 125                 /// have no overlap with spans from <code>exclude</code>.
 126                 /// </summary>
 127                 public SpanNotQuery(SpanQuery include, SpanQuery exclude)
 128                 {
 129                         this.include = include;
 130                         this.exclude = exclude;
 131
 132                         if (!include.GetField().Equals(exclude.GetField()))
 133                                 throw new System.ArgumentException("Clauses must have same Field.");
 134                 }
 135
 136                 /// <summary>Return the SpanQuery whose matches are filtered. </summary>
 137                 public virtual SpanQuery GetInclude()
 138                 {
 139                         return include;
 140                 }
 141
 142                 /// <summary>Return the SpanQuery whose matches must not overlap those returned. </summary>
 143                 public virtual SpanQuery GetExclude()
 144                 {
 145                         return exclude;
 146                 }
 147
 148                 public override System.String GetField()
 149                 {
 150                         return include.GetField();
 151                 }
 152
 153                 public override System.Collections.ICollection GetTerms()
 154                 {
 155                         return include.GetTerms();
 156                 }
 157
 158                 public override System.String ToString(System.String field)
 159                 {
 160                         System.Text.StringBuilder buffer = new System.Text.StringBuilder();
 161                         buffer.Append("spanNot(");
 162                         buffer.Append(include.ToString(field));
 163                         buffer.Append(", ");
 164                         buffer.Append(exclude.ToString(field));
 165                         buffer.Append(")");
 166                         return buffer.ToString();
 167                 }
 168
 169
 170                 public override Spans GetSpans(IndexReader reader)
 171                 {
 172                         return new AnonymousClassSpans(reader, this);
 173                 }
 174         }
 175 }