beagled/Lucene.Net/Index/SegmentTermDocs.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 IndexInput = Lucene.Net.Store.IndexInput;
  19 using BitVector = Lucene.Net.Util.BitVector;
  20
  21 namespace Lucene.Net.Index
  22 {
  23
  24         public class SegmentTermDocs : TermDocs
  25         {
  26                 protected internal SegmentReader parent;
  27                 protected internal IndexInput freqStream;
  28                 protected internal int count;
  29                 protected internal int df;
  30                 protected internal BitVector deletedDocs;
  31                 internal int doc = 0;
  32                 internal int freq;
  33
  34                 private int skipInterval;
  35                 private int numSkips;
  36                 private int skipCount;
  37                 private IndexInput skipStream;
  38                 private int skipDoc;
  39                 private long freqPointer;
  40                 private long proxPointer;
  41                 private long skipPointer;
  42                 private bool haveSkipped;
  43
  44                 public SegmentTermDocs(SegmentReader parent)
  45                 {
  46                         this.parent = parent;
  47                         this.freqStream = (IndexInput) parent.freqStream.Clone();
  48                         this.deletedDocs = parent.deletedDocs;
  49                         this.skipInterval = parent.tis.GetSkipInterval();
  50                 }
  51
  52                 public virtual void  Seek(Term term)
  53                 {
  54                         TermInfo ti = parent.tis.Get(term);
  55                         Seek(ti);
  56                 }
  57
  58                 public virtual void  Seek(TermEnum termEnum)
  59                 {
  60                         TermInfo ti;
  61
  62                         // use comparison of fieldinfos to verify that termEnum belongs to the same segment as this SegmentTermDocs
  63                         if (termEnum is SegmentTermEnum && ((SegmentTermEnum) termEnum).fieldInfos == parent.fieldInfos)
  64                         // optimized case
  65                                 ti = ((SegmentTermEnum) termEnum).TermInfo();
  66                         // punt case
  67                         else
  68                                 ti = parent.tis.Get(termEnum.Term());
  69
  70                         Seek(ti);
  71                 }
  72
  73                 internal virtual void  Seek(TermInfo ti)
  74                 {
  75                         count = 0;
  76                         if (ti == null)
  77                         {
  78                                 df = 0;
  79                         }
  80                         else
  81                         {
  82                                 df = ti.docFreq;
  83                                 doc = 0;
  84                                 skipDoc = 0;
  85                                 skipCount = 0;
  86                                 numSkips = df / skipInterval;
  87                                 freqPointer = ti.freqPointer;
  88                                 proxPointer = ti.proxPointer;
  89                                 skipPointer = freqPointer + ti.skipOffset;
  90                                 freqStream.Seek(freqPointer);
  91                                 haveSkipped = false;
  92                         }
  93                 }
  94
  95                 public virtual void  Close()
  96                 {
  97                         freqStream.Close();
  98                         if (skipStream != null)
  99                                 skipStream.Close();
 100                 }
 101
 102                 public int Doc()
 103                 {
 104                         return doc;
 105                 }
 106                 public int Freq()
 107                 {
 108                         return freq;
 109                 }
 110
 111                 protected internal virtual void  SkippingDoc()
 112                 {
 113                 }
 114
 115                 public virtual bool Next()
 116                 {
 117                         while (true)
 118                         {
 119                                 if (count == df)
 120                                         return false;
 121
 122                                 int docCode = freqStream.ReadVInt();
 123                                 doc += (int) (((uint) docCode) >> 1); // shift off low bit
 124                                 if ((docCode & 1) != 0)
 125                                 // if low bit is set
 126                                         freq = 1;
 127                                 // freq is one
 128                                 else
 129                                         freq = freqStream.ReadVInt(); // else read freq
 130
 131                                 count++;
 132
 133                                 if (deletedDocs == null || !deletedDocs.Get(doc))
 134                                         break;
 135                                 SkippingDoc();
 136                         }
 137                         return true;
 138                 }
 139
 140                 /// <summary>Optimized implementation. </summary>
 141                 public virtual int Read(int[] docs, int[] freqs)
 142                 {
 143                         int length = docs.Length;
 144                         int i = 0;
 145                         while (i < length && count < df)
 146                         {
 147
 148                                 // manually inlined call to next() for speed
 149                                 int docCode = freqStream.ReadVInt();
 150                                 doc += (int) (((uint) docCode) >> 1); // shift off low bit
 151                                 if ((docCode & 1) != 0)
 152                                 // if low bit is set
 153                                         freq = 1;
 154                                 // freq is one
 155                                 else
 156                                         freq = freqStream.ReadVInt(); // else read freq
 157                                 count++;
 158
 159                                 if (deletedDocs == null || !deletedDocs.Get(doc))
 160                                 {
 161                                         docs[i] = doc;
 162                                         freqs[i] = freq;
 163                                         ++i;
 164                                 }
 165                         }
 166                         return i;
 167                 }
 168
 169                 /// <summary>Overridden by SegmentTermPositions to skip in prox stream. </summary>
 170                 protected internal virtual void  SkipProx(long proxPointer)
 171                 {
 172                 }
 173
 174                 /// <summary>Optimized implementation. </summary>
 175                 public virtual bool SkipTo(int target)
 176                 {
 177                         if (df >= skipInterval)
 178                         {
 179                                 // optimized case
 180
 181                                 if (skipStream == null)
 182                                         skipStream = (IndexInput) freqStream.Clone(); // lazily clone
 183
 184                                 if (!haveSkipped)
 185                                 {
 186                                         // lazily seek skip stream
 187                                         skipStream.Seek(skipPointer);
 188                                         haveSkipped = true;
 189                                 }
 190
 191                                 // scan skip data
 192                                 int lastSkipDoc = skipDoc;
 193                                 long lastFreqPointer = freqStream.GetFilePointer();
 194                                 long lastProxPointer = - 1;
 195                                 int numSkipped = - 1 - (count % skipInterval);
 196
 197                                 while (target > skipDoc)
 198                                 {
 199                                         lastSkipDoc = skipDoc;
 200                                         lastFreqPointer = freqPointer;
 201                                         lastProxPointer = proxPointer;
 202
 203                                         if (skipDoc != 0 && skipDoc >= doc)
 204                                                 numSkipped += skipInterval;
 205
 206                                         if (skipCount >= numSkips)
 207                                                 break;
 208
 209                                         skipDoc += skipStream.ReadVInt();
 210                                         freqPointer += skipStream.ReadVInt();
 211                                         proxPointer += skipStream.ReadVInt();
 212
 213                                         skipCount++;
 214                                 }
 215
 216                                 // if we found something to skip, then skip it
 217                                 if (lastFreqPointer > freqStream.GetFilePointer())
 218                                 {
 219                                         freqStream.Seek(lastFreqPointer);
 220                                         SkipProx(lastProxPointer);
 221
 222                                         doc = lastSkipDoc;
 223                                         count += numSkipped;
 224                                 }
 225                         }
 226
 227                         // done skipping, now just scan
 228                         do
 229                         {
 230                                 if (!Next())
 231                                         return false;
 232                         }
 233                         while (target > doc);
 234                         return true;
 235                 }
 236         }
 237 }