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