beagled/Lucene.Net/Index/TermInfosReader.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 Directory = Lucene.Net.Store.Directory;
  19
  20 namespace Lucene.Net.Index
  21 {
  22
  23         /// <summary>This stores a monotonically increasing set of <Term, TermInfo> pairs in a
  24         /// Directory.  Pairs are accessed either by Term or by ordinal position the
  25         /// set.
  26         /// </summary>
  27
  28         public sealed class TermInfosReader
  29         {
  30                 private Directory directory;
  31                 private System.String segment;
  32                 private FieldInfos fieldInfos;
  33
  34                 private System.LocalDataStoreSlot enumerators = System.Threading.Thread.AllocateDataSlot();
  35                 private SegmentTermEnum origEnum;
  36                 private long size;
  37
  38                 private Term[] indexTerms = null;
  39                 private TermInfo[] indexInfos;
  40                 private long[] indexPointers;
  41
  42                 private SegmentTermEnum indexEnum;
  43
  44                 public /*internal*/ TermInfosReader(Directory dir, System.String seg, FieldInfos fis)
  45                 {
  46                         directory = dir;
  47                         segment = seg;
  48                         fieldInfos = fis;
  49
  50                         origEnum = new SegmentTermEnum(directory.OpenInput(segment + ".tis"), fieldInfos, false);
  51                         size = origEnum.size;
  52
  53                         indexEnum = new SegmentTermEnum(directory.OpenInput(segment + ".tii"), fieldInfos, true);
  54                 }
  55
  56         /*  Leaving this here will cause a memory leak under .NET 1.1
  57         ~TermInfosReader()
  58                 {
  59             // patch for pre-1.4.2 JVMs, whose ThreadLocals leak
  60             //System.Threading.Thread.SetData(enumerators, null);
  61                 }
  62         */
  63
  64                 public int GetSkipInterval()
  65                 {
  66                         return origEnum.skipInterval;
  67                 }
  68
  69                 public /*internal*/ void  Close()
  70                 {
  71                         if (origEnum != null)
  72                                 origEnum.Close();
  73                         if (indexEnum != null)
  74                                 indexEnum.Close();
  75                 }
  76
  77                 /// <summary>Returns the number of term/value pairs in the set. </summary>
  78                 internal long Size()
  79                 {
  80                         return size;
  81                 }
  82
  83                 private SegmentTermEnum GetEnum()
  84                 {
  85                         SegmentTermEnum termEnum = (SegmentTermEnum) System.Threading.Thread.GetData(enumerators);
  86                         if (termEnum == null)
  87                         {
  88                                 termEnum = Terms();
  89                                 System.Threading.Thread.SetData(enumerators, termEnum);
  90                         }
  91                         return termEnum;
  92                 }
  93
  94                 private void  EnsureIndexIsRead()
  95                 {
  96                         lock (this)
  97                         {
  98                                 if (indexTerms != null)
  99                                 // index already read
 100                                         return ; // do nothing
 101                                 try
 102                                 {
 103                                         int indexSize = (int) indexEnum.size; // otherwise read index
 104
 105                                         indexTerms = new Term[indexSize];
 106                                         indexInfos = new TermInfo[indexSize];
 107                                         indexPointers = new long[indexSize];
 108
 109                                         for (int i = 0; indexEnum.Next(); i++)
 110                                         {
 111                                                 indexTerms[i] = indexEnum.Term();
 112                                                 indexInfos[i] = indexEnum.TermInfo();
 113                                                 indexPointers[i] = indexEnum.indexPointer;
 114                                         }
 115                                 }
 116                                 finally
 117                                 {
 118                                         indexEnum.Close();
 119                                         indexEnum = null;
 120                                 }
 121                         }
 122                 }
 123
 124                 /// <summary>Returns the offset of the greatest index entry which is less than or equal to term.</summary>
 125                 private int GetIndexOffset(Term term)
 126                 {
 127                         int lo = 0; // binary search indexTerms[]
 128                         int hi = indexTerms.Length - 1;
 129
 130                         while (hi >= lo)
 131                         {
 132                                 int mid = (lo + hi) >> 1;
 133                                 int delta = term.CompareTo(indexTerms[mid]);
 134                                 if (delta < 0)
 135                                         hi = mid - 1;
 136                                 else if (delta > 0)
 137                                         lo = mid + 1;
 138                                 else
 139                                         return mid;
 140                         }
 141                         return hi;
 142                 }
 143
 144                 private void  SeekEnum(int indexOffset)
 145                 {
 146                         GetEnum().Seek(indexPointers[indexOffset], (indexOffset * GetEnum().indexInterval) - 1, indexTerms[indexOffset], indexInfos[indexOffset]);
 147                 }
 148
 149                 /// <summary>Returns the TermInfo for a Term in the set, or null. </summary>
 150                 public /*internal*/ TermInfo Get(Term term)
 151                 {
 152                         if (size == 0)
 153                                 return null;
 154
 155                         EnsureIndexIsRead();
 156
 157                         // optimize sequential access: first try scanning cached enum w/o seeking
 158                         SegmentTermEnum enumerator = GetEnum();
 159                         if (enumerator.Term() != null && ((enumerator.Prev() != null && term.CompareTo(enumerator.Prev()) > 0) || term.CompareTo(enumerator.Term()) >= 0))
 160                         {
 161                                 int enumOffset = (int) (enumerator.position / enumerator.indexInterval) + 1;
 162                                 if (indexTerms.Length == enumOffset || term.CompareTo(indexTerms[enumOffset]) < 0)
 163                                         return ScanEnum(term); // no need to seek
 164                         }
 165
 166                         // random-access: must seek
 167                         SeekEnum(GetIndexOffset(term));
 168                         return ScanEnum(term);
 169                 }
 170
 171                 /// <summary>Scans within block for matching term. </summary>
 172                 private TermInfo ScanEnum(Term term)
 173                 {
 174                         SegmentTermEnum enumerator = GetEnum();
 175                         enumerator.ScanTo(term);
 176                         if (enumerator.Term() != null && term.CompareTo(enumerator.Term()) == 0)
 177                                 return enumerator.TermInfo();
 178                         else
 179                                 return null;
 180                 }
 181
 182                 /// <summary>Returns the nth term in the set. </summary>
 183                 internal Term Get(int position)
 184                 {
 185                         if (size == 0)
 186                                 return null;
 187
 188                         SegmentTermEnum enumerator = GetEnum();
 189                         if (enumerator != null && enumerator.Term() != null && position >= enumerator.position && position < (enumerator.position + enumerator.indexInterval))
 190                                 return ScanEnum(position); // can avoid seek
 191
 192                         SeekEnum(position / enumerator.indexInterval); // must seek
 193                         return ScanEnum(position);
 194                 }
 195
 196                 private Term ScanEnum(int position)
 197                 {
 198                         SegmentTermEnum enumerator = GetEnum();
 199                         while (enumerator.position < position)
 200                                 if (!enumerator.Next())
 201                                         return null;
 202
 203                         return enumerator.Term();
 204                 }
 205
 206                 /// <summary>Returns the position of a Term in the set or -1. </summary>
 207                 internal long GetPosition(Term term)
 208                 {
 209                         if (size == 0)
 210                                 return - 1;
 211
 212                         EnsureIndexIsRead();
 213                         int indexOffset = GetIndexOffset(term);
 214                         SeekEnum(indexOffset);
 215
 216                         SegmentTermEnum enumerator = GetEnum();
 217                         while (term.CompareTo(enumerator.Term()) > 0 && enumerator.Next())
 218                         {
 219                         }
 220
 221                         if (term.CompareTo(enumerator.Term()) == 0)
 222                                 return enumerator.position;
 223                         else
 224                                 return - 1;
 225                 }
 226
 227                 /// <summary>Returns an enumeration of all the Terms and TermInfos in the set. </summary>
 228                 public SegmentTermEnum Terms()
 229                 {
 230                         return (SegmentTermEnum) origEnum.Clone();
 231                 }
 232
 233                 /// <summary>Returns an enumeration of terms starting at or after the named term. </summary>
 234                 public SegmentTermEnum Terms(Term term)
 235                 {
 236                         Get(term);
 237                         return (SegmentTermEnum) GetEnum().Clone();
 238                 }
 239         }
 240 }