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