beagled/Lucene.Net/Search/Spans/SpanOrQuery.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 PriorityQueue = Lucene.Net.Util.PriorityQueue;
  19 namespace Lucene.Net.Search.Spans
  20 {
  21
  22         /// <summary>Matches the union of its clauses.</summary>
  23         [Serializable]
  24         public class SpanOrQuery : SpanQuery
  25         {
  26                 private class AnonymousClassSpans : Spans
  27                 {
  28                         public AnonymousClassSpans(Lucene.Net.Index.IndexReader reader, SpanOrQuery enclosingInstance)
  29                         {
  30                                 InitBlock(reader, enclosingInstance);
  31                         }
  32                         private void  InitBlock(Lucene.Net.Index.IndexReader reader, SpanOrQuery enclosingInstance)
  33                         {
  34                                 this.reader = reader;
  35                                 this.enclosingInstance = enclosingInstance;
  36                                 all = new System.Collections.ArrayList(Enclosing_Instance.clauses.Count);
  37                                 queue = new SpanQueue(enclosingInstance, Enclosing_Instance.clauses.Count);
  38                                 System.Collections.IEnumerator i = Enclosing_Instance.clauses.GetEnumerator();
  39                                 while (i.MoveNext())
  40                                 {
  41                                         // initialize all
  42                                         all.Add(((SpanQuery) i.Current).GetSpans(reader));
  43                                 }
  44                         }
  45                         private Lucene.Net.Index.IndexReader reader;
  46                         private SpanOrQuery enclosingInstance;
  47                         public SpanOrQuery Enclosing_Instance
  48                         {
  49                                 get
  50                                 {
  51                                         return enclosingInstance;
  52                                 }
  53
  54                         }
  55                         private System.Collections.IList all;
  56                         private SpanQueue queue;
  57
  58                         private bool firstTime = true;
  59
  60                         public virtual bool Next()
  61                         {
  62                                 if (firstTime)
  63                                 {
  64                                         // first time -- initialize
  65                                         for (int i = 0; i < all.Count; i++)
  66                                         {
  67                                                 Spans spans = (Spans) all[i];
  68                                                 if (spans.Next())
  69                                                 {
  70                                                         // move to first entry
  71                                                         queue.Put(spans); // build queue
  72                                                 }
  73                                                 else
  74                                                 {
  75                                                         all.RemoveAt(i--);
  76                                                 }
  77                                         }
  78                                         firstTime = false;
  79                                         return queue.Size() != 0;
  80                                 }
  81
  82                                 if (queue.Size() == 0)
  83                                 {
  84                                         // all done
  85                                         return false;
  86                                 }
  87
  88                                 if (Top().Next())
  89                                 {
  90                                         // move to next
  91                                         queue.AdjustTop();
  92                                         return true;
  93                                 }
  94
  95                                 all.Remove(queue.Pop()); // exhausted a clause
  96
  97                                 return queue.Size() != 0;
  98                         }
  99
 100                         private Spans Top()
 101                         {
 102                                 return (Spans) queue.Top();
 103                         }
 104
 105                         public virtual bool SkipTo(int target)
 106                         {
 107                                 if (firstTime)
 108                                 {
 109                                         for (int i = 0; i < all.Count; i++)
 110                                         {
 111                                                 Spans spans = (Spans) all[i];
 112                                                 if (spans.SkipTo(target))
 113                                                 {
 114                                                         // skip each spans in all
 115                                                         queue.Put(spans); // build queue
 116                                                 }
 117                                                 else
 118                                                 {
 119                                                         all.RemoveAt(i--);
 120                                                 }
 121                                         }
 122                                         firstTime = false;
 123                                 }
 124                                 else
 125                                 {
 126                                         while (queue.Size() != 0 && Top().Doc() < target)
 127                                         {
 128                                                 if (Top().SkipTo(target))
 129                                                 {
 130                                                         queue.AdjustTop();
 131                                                 }
 132                                                 else
 133                                                 {
 134                                                         all.Remove(queue.Pop());
 135                                                 }
 136                                         }
 137                                 }
 138
 139                                 return queue.Size() != 0;
 140                         }
 141
 142                         public virtual int Doc()
 143                         {
 144                                 return Top().Doc();
 145                         }
 146                         public virtual int Start()
 147                         {
 148                                 return Top().Start();
 149                         }
 150                         public virtual int End()
 151                         {
 152                                 return Top().End();
 153                         }
 154
 155                         public override System.String ToString()
 156                         {
 157                                 return "spans(" + Enclosing_Instance + ")@" + (firstTime?"START":(queue.Size() > 0?(Doc() + ":" + Start() + "-" + End()):"END"));
 158                         }
 159                 }
 160                 private System.Collections.ArrayList clauses;
 161                 private System.String field;
 162
 163                 /// <summary>Construct a SpanOrQuery merging the provided clauses. </summary>
 164                 public SpanOrQuery(SpanQuery[] clauses)
 165                 {
 166
 167                         // copy clauses array into an ArrayList
 168                         this.clauses = new System.Collections.ArrayList(clauses.Length);
 169                         for (int i = 0; i < clauses.Length; i++)
 170                         {
 171                                 SpanQuery clause = clauses[i];
 172                                 if (i == 0)
 173                                 {
 174                                         // check Field
 175                                         field = clause.GetField();
 176                                 }
 177                                 else if (!clause.GetField().Equals(field))
 178                                 {
 179                                         throw new System.ArgumentException("Clauses must have same Field.");
 180                                 }
 181                                 this.clauses.Add(clause);
 182                         }
 183                 }
 184
 185                 /// <summary>Return the clauses whose spans are matched. </summary>
 186                 public virtual SpanQuery[] GetClauses()
 187                 {
 188             return (SpanQuery[]) clauses.ToArray(typeof(SpanQuery[]));
 189                 }
 190
 191                 public override System.String GetField()
 192                 {
 193                         return field;
 194                 }
 195
 196                 public override System.Collections.ICollection GetTerms()
 197                 {
 198                         System.Collections.ArrayList terms = new System.Collections.ArrayList();
 199                         System.Collections.IEnumerator i = clauses.GetEnumerator();
 200                         while (i.MoveNext())
 201                         {
 202                                 SpanQuery clause = (SpanQuery) i.Current;
 203                                 terms.AddRange(clause.GetTerms());
 204                         }
 205                         return terms;
 206                 }
 207
 208                 public override System.String ToString(System.String field)
 209                 {
 210                         System.Text.StringBuilder buffer = new System.Text.StringBuilder();
 211                         buffer.Append("spanOr([");
 212                         System.Collections.IEnumerator i = clauses.GetEnumerator();
 213                         while (i.MoveNext())
 214                         {
 215                                 SpanQuery clause = (SpanQuery) i.Current;
 216                                 buffer.Append(clause.ToString(field));
 217                                 if (i.MoveNext())
 218                                 {
 219                                         buffer.Append(", ");
 220                                 }
 221                         }
 222                         buffer.Append("])");
 223                         return buffer.ToString();
 224                 }
 225
 226                 private class SpanQueue:PriorityQueue
 227                 {
 228                         private void  InitBlock(SpanOrQuery enclosingInstance)
 229                         {
 230                                 this.enclosingInstance = enclosingInstance;
 231                         }
 232                         private SpanOrQuery enclosingInstance;
 233                         public SpanOrQuery Enclosing_Instance
 234                         {
 235                                 get
 236                                 {
 237                                         return enclosingInstance;
 238                                 }
 239
 240                         }
 241                         public SpanQueue(SpanOrQuery enclosingInstance, int size)
 242                         {
 243                                 InitBlock(enclosingInstance);
 244                                 Initialize(size);
 245                         }
 246
 247                         public override bool LessThan(System.Object o1, System.Object o2)
 248                         {
 249                                 Spans spans1 = (Spans) o1;
 250                                 Spans spans2 = (Spans) o2;
 251                                 if (spans1.Doc() == spans2.Doc())
 252                                 {
 253                                         if (spans1.Start() == spans2.Start())
 254                                         {
 255                                                 return spans1.End() < spans2.End();
 256                                         }
 257                                         else
 258                                         {
 259                                                 return spans1.Start() < spans2.Start();
 260                                         }
 261                                 }
 262                                 else
 263                                 {
 264                                         return spans1.Doc() < spans2.Doc();
 265                                 }
 266                         }
 267                 }
 268
 269
 270                 public override Spans GetSpans(IndexReader reader)
 271                 {
 272                         if (clauses.Count == 1)
 273                         // optimize 1-clause case
 274                                 return ((SpanQuery) clauses[0]).GetSpans(reader);
 275
 276                         return new AnonymousClassSpans(reader, this);
 277                 }
 278         }
 279 }