beagled/Lucene.Net/Index/MultipleTermPositions.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 PriorityQueue = Lucene.Net.Util.PriorityQueue;
  19
  20 namespace Lucene.Net.Index
  21 {
  22
  23         /// <summary> Describe class <code>MultipleTermPositions</code> here.
  24         ///
  25         /// </summary>
  26         /// <author>  Anders Nielsen
  27         /// </author>
  28         /// <version>  1.0
  29         /// </version>
  30         public class MultipleTermPositions : TermPositions
  31         {
  32
  33                 private sealed class TermPositionsQueue:PriorityQueue
  34                 {
  35                         internal TermPositionsQueue(System.Collections.IList termPositions)
  36                         {
  37                                 Initialize(termPositions.Count);
  38
  39                                 System.Collections.IEnumerator i = termPositions.GetEnumerator();
  40                                 while (i.MoveNext())
  41                                 {
  42                                         TermPositions tp = (TermPositions) i.Current;
  43                                         if (tp.Next())
  44                                                 Put(tp);
  45                                 }
  46                         }
  47
  48                         internal TermPositions Peek()
  49                         {
  50                                 return (TermPositions) Top();
  51                         }
  52
  53                         public override bool LessThan(System.Object a, System.Object b)
  54                         {
  55                                 return ((TermPositions) a).Doc() < ((TermPositions) b).Doc();
  56                         }
  57                 }
  58
  59                 private sealed class IntQueue
  60                 {
  61                         public IntQueue()
  62                         {
  63                                 InitBlock();
  64                         }
  65                         private void  InitBlock()
  66                         {
  67                                 _array = new int[_arraySize];
  68                         }
  69                         private int _arraySize = 16;
  70                         private int _index = 0;
  71                         private int _lastIndex = 0;
  72                         private int[] _array;
  73
  74                         internal void  Add(int i)
  75                         {
  76                                 if (_lastIndex == _arraySize)
  77                                         GrowArray();
  78
  79                                 _array[_lastIndex++] = i;
  80                         }
  81
  82                         internal int Next()
  83                         {
  84                                 return _array[_index++];
  85                         }
  86
  87                         internal void  Sort()
  88                         {
  89                                 System.Array.Sort(_array, _index, _lastIndex - _index);
  90                         }
  91
  92                         internal void  Clear()
  93                         {
  94                                 _index = 0;
  95                                 _lastIndex = 0;
  96                         }
  97
  98                         internal int Size()
  99                         {
 100                                 return (_lastIndex - _index);
 101                         }
 102
 103                         private void  GrowArray()
 104                         {
 105                                 int[] newArray = new int[_arraySize * 2];
 106                                 Array.Copy(_array, 0, newArray, 0, _arraySize);
 107                                 _array = newArray;
 108                                 _arraySize *= 2;
 109                         }
 110                 }
 111
 112                 private int _doc;
 113                 private int _freq;
 114                 private TermPositionsQueue _termPositionsQueue;
 115                 private IntQueue _posList;
 116
 117                 /// <summary> Creates a new <code>MultipleTermPositions</code> instance.
 118                 ///
 119                 /// </summary>
 120                 /// <exception cref="IOException">
 121                 /// </exception>
 122                 public MultipleTermPositions(IndexReader indexReader, Term[] terms)
 123                 {
 124                         System.Collections.IList termPositions = new System.Collections.ArrayList();
 125
 126                         for (int i = 0; i < terms.Length; i++)
 127                                 termPositions.Add(indexReader.TermPositions(terms[i]));
 128
 129                         _termPositionsQueue = new TermPositionsQueue(termPositions);
 130                         _posList = new IntQueue();
 131                 }
 132
 133                 public bool Next()
 134                 {
 135                         if (_termPositionsQueue.Size() == 0)
 136                                 return false;
 137
 138                         _posList.Clear();
 139                         _doc = _termPositionsQueue.Peek().Doc();
 140
 141                         TermPositions tp;
 142                         do
 143                         {
 144                                 tp = _termPositionsQueue.Peek();
 145
 146                                 for (int i = 0; i < tp.Freq(); i++)
 147                                         _posList.Add(tp.NextPosition());
 148
 149                                 if (tp.Next())
 150                                         _termPositionsQueue.AdjustTop();
 151                                 else
 152                                 {
 153                                         _termPositionsQueue.Pop();
 154                                         tp.Close();
 155                                 }
 156                         }
 157                         while (_termPositionsQueue.Size() > 0 && _termPositionsQueue.Peek().Doc() == _doc);
 158
 159                         _posList.Sort();
 160                         _freq = _posList.Size();
 161
 162                         return true;
 163                 }
 164
 165                 public int NextPosition()
 166                 {
 167                         return _posList.Next();
 168                 }
 169
 170                 public bool SkipTo(int target)
 171                 {
 172                         while (_termPositionsQueue.Peek() != null && target > _termPositionsQueue.Peek().Doc())
 173                         {
 174                                 TermPositions tp = (TermPositions) _termPositionsQueue.Pop();
 175                                 if (tp.SkipTo(target))
 176                                         _termPositionsQueue.Put(tp);
 177                                 else
 178                                         tp.Close();
 179                         }
 180                         return Next();
 181                 }
 182
 183                 public int Doc()
 184                 {
 185                         return _doc;
 186                 }
 187
 188                 public int Freq()
 189                 {
 190                         return _freq;
 191                 }
 192
 193                 public void  Close()
 194                 {
 195                         while (_termPositionsQueue.Size() > 0)
 196                                 ((TermPositions) _termPositionsQueue.Pop()).Close();
 197                 }
 198
 199                 /// <summary> Not implemented.</summary>
 200                 /// <throws>  UnsupportedOperationException </throws>
 201                 public virtual void  Seek(Term arg0)
 202                 {
 203                         throw new System.NotSupportedException();
 204                 }
 205
 206                 /// <summary> Not implemented.</summary>
 207                 /// <throws>  UnsupportedOperationException </throws>
 208                 public virtual void  Seek(TermEnum termEnum)
 209                 {
 210                         throw new System.NotSupportedException();
 211                 }
 212
 213                 /// <summary> Not implemented.</summary>
 214                 /// <throws>  UnsupportedOperationException </throws>
 215                 public virtual int Read(int[] arg0, int[] arg1)
 216                 {
 217                         throw new System.NotSupportedException();
 218                 }
 219         }
 220 }