beagled/Lucene.Net/Index/SegmentReader.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 Document = Lucene.Net.Documents.Document;
  18 using Field = Lucene.Net.Documents.Field;
  19 using Directory = Lucene.Net.Store.Directory;
  20 using IndexInput = Lucene.Net.Store.IndexInput;
  21 using IndexOutput = Lucene.Net.Store.IndexOutput;
  22 using BitVector = Lucene.Net.Util.BitVector;
  23 namespace Lucene.Net.Index
  24 {
  25
  26         /// <summary> FIXME: Describe class <code>SegmentReader</code> here.
  27         ///
  28         /// </summary>
  29         /// <version>  $Id: SegmentReader.cs,v 1.6 2006/04/26 19:19:53 joeshaw Exp $
  30         /// </version>
  31         class SegmentReader : IndexReader
  32         {
  33                 private System.String segment;
  34
  35                 internal FieldInfos fieldInfos;
  36                 private FieldsReader fieldsReader;
  37
  38                 internal TermInfosReader tis;
  39         internal TermVectorsReader termVectorsReaderOrig = null;
  40         internal System.LocalDataStoreSlot termVectorsLocal = System.Threading.Thread.AllocateDataSlot();
  41
  42                 internal BitVector deletedDocs = null;
  43                 private bool deletedDocsDirty = false;
  44                 private bool normsDirty = false;
  45                 private bool undeleteAll = false;
  46
  47                 internal IndexInput freqStream;
  48                 internal IndexInput proxStream;
  49
  50                 // Compound File Reader when based on a compound file segment
  51                 internal CompoundFileReader cfsReader = null;
  52
  53                 private class Norm
  54                 {
  55                         private void  InitBlock(SegmentReader enclosingInstance)
  56                         {
  57                                 this.enclosingInstance = enclosingInstance;
  58                         }
  59                         private SegmentReader enclosingInstance;
  60                         public SegmentReader Enclosing_Instance
  61                         {
  62                                 get
  63                                 {
  64                                         return enclosingInstance;
  65                                 }
  66
  67                         }
  68                         public Norm(SegmentReader enclosingInstance, IndexInput in_Renamed, int number)
  69                         {
  70                                 InitBlock(enclosingInstance);
  71                                 this.in_Renamed = in_Renamed;
  72                                 this.number = number;
  73                         }
  74
  75                         public IndexInput in_Renamed;   // private -> public
  76                         public byte[] bytes;            // private -> public
  77                         public bool dirty;              // private -> public
  78                         public int number;              // private -> public
  79
  80                         public void  ReWrite()          // private -> public
  81                         {
  82                                 // NOTE: norms are re-written in regular directory, not cfs
  83                                 IndexOutput out_Renamed = Enclosing_Instance.Directory().CreateOutput(Enclosing_Instance.segment + ".tmp");
  84                                 try
  85                                 {
  86                                         out_Renamed.WriteBytes(bytes, Enclosing_Instance.MaxDoc());
  87                                 }
  88                                 finally
  89                                 {
  90                                         out_Renamed.Close();
  91                                 }
  92                                 System.String fileName;
  93                 if (Enclosing_Instance.cfsReader == null)
  94                     fileName = Enclosing_Instance.segment + ".f" + number;
  95                 else
  96                 {
  97                     // use a different file name if we have compound format
  98                     fileName = Enclosing_Instance.segment + ".s" + number;
  99                 }
 100                 Enclosing_Instance.Directory().RenameFile(Enclosing_Instance.segment + ".tmp", fileName);
 101                 this.dirty = false;
 102                         }
 103                 }
 104
 105                 private System.Collections.Hashtable norms = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
 106
 107         /// <summary>The class which implements SegmentReader. </summary>
 108         private static System.Type IMPL;
 109
 110         public SegmentReader() : base(null)
 111         {
 112         }
 113
 114         public static SegmentReader Get(SegmentInfo si)
 115         {
 116             return Get(si.dir, si, null, false, false);
 117         }
 118
 119         public static SegmentReader Get(SegmentInfos sis, SegmentInfo si, bool closeDir)
 120         {
 121             return Get(si.dir, si, sis, closeDir, true);
 122         }
 123
 124         public static SegmentReader Get(Directory dir, SegmentInfo si, SegmentInfos sis, bool closeDir, bool ownDir)
 125         {
 126             SegmentReader instance;
 127             try
 128             {
 129                 instance = (SegmentReader) System.Activator.CreateInstance(IMPL);
 130             }
 131             catch (System.Exception e)
 132             {
 133                 throw new System.SystemException("cannot load SegmentReader class: " + e.ToString());
 134             }
 135             instance.Init(dir, sis, closeDir, ownDir);
 136             instance.Initialize(si);
 137             return instance;
 138         }
 139
 140                 private void  Initialize(SegmentInfo si)
 141                 {
 142                         segment = si.name;
 143
 144                         // Use compound file directory for some files, if it exists
 145                         Directory cfsDir = Directory();
 146                         if (Directory().FileExists(segment + ".cfs"))
 147                         {
 148                                 cfsReader = new CompoundFileReader(Directory(), segment + ".cfs");
 149                                 cfsDir = cfsReader;
 150                         }
 151
 152                         // No compound file exists - use the multi-file format
 153                         fieldInfos = new FieldInfos(cfsDir, segment + ".fnm");
 154                         fieldsReader = new FieldsReader(cfsDir, segment, fieldInfos);
 155
 156                         tis = new TermInfosReader(cfsDir, segment, fieldInfos);
 157
 158                         // NOTE: the bitvector is stored using the regular directory, not cfs
 159                         if (HasDeletions(si))
 160                                 deletedDocs = new BitVector(Directory(), segment + ".del");
 161
 162                         // make sure that all index files have been read or are kept open
 163                         // so that if an index update removes them we'll still have them
 164                         freqStream = cfsDir.OpenInput(segment + ".frq");
 165                         proxStream = cfsDir.OpenInput(segment + ".prx");
 166                         OpenNorms(cfsDir);
 167
 168                         if (fieldInfos.HasVectors())
 169                         {
 170                                 // open term vector files only as needed
 171                                 termVectorsReaderOrig = new TermVectorsReader(cfsDir, segment, fieldInfos);
 172                         }
 173                 }
 174
 175         ~SegmentReader()
 176         {
 177             // patch for pre-1.4.2 JVMs, whose ThreadLocals leak
 178             try
 179             {
 180                 System.Threading.Thread.SetData(termVectorsLocal, null);     // {{Aroush-1.9}} is this required for .NET ?!
 181             }
 182             catch (Exception ex)
 183             {
 184                 // System.Console.WriteLine(ex.Message);
 185             }
 186         }
 187
 188                 protected internal override void  DoCommit()
 189                 {
 190                         if (deletedDocsDirty)
 191                         {
 192                                 // re-write deleted
 193                                 deletedDocs.Write(Directory(), segment + ".tmp");
 194                                 Directory().RenameFile(segment + ".tmp", segment + ".del");
 195                         }
 196                         if (undeleteAll && Directory().FileExists(segment + ".del"))
 197                         {
 198                                 Directory().DeleteFile(segment + ".del");
 199                         }
 200                         if (normsDirty)
 201                         {
 202                                 // re-write norms
 203                                 System.Collections.IEnumerator values = norms.Values.GetEnumerator();
 204                                 while (values.MoveNext())
 205                                 {
 206                                         Norm norm = (Norm) values.Current;
 207                                         if (norm.dirty)
 208                                         {
 209                                                 norm.ReWrite();
 210                                         }
 211                                 }
 212                         }
 213                         deletedDocsDirty = false;
 214                         normsDirty = false;
 215                         undeleteAll = false;
 216                 }
 217
 218                 protected internal override void  DoClose()
 219                 {
 220                         fieldsReader.Close();
 221                         tis.Close();
 222
 223                         if (freqStream != null)
 224                                 freqStream.Close();
 225                         if (proxStream != null)
 226                                 proxStream.Close();
 227
 228                         CloseNorms();
 229
 230             if (termVectorsReaderOrig != null)
 231                 termVectorsReaderOrig.Close();
 232
 233                         if (cfsReader != null)
 234                                 cfsReader.Close();
 235                 }
 236
 237                 internal static bool HasDeletions(SegmentInfo si)
 238                 {
 239                         return si.dir.FileExists(si.name + ".del");
 240                 }
 241
 242                 public override bool HasDeletions()
 243                 {
 244                         return deletedDocs != null;
 245                 }
 246
 247
 248                 internal static bool UsesCompoundFile(SegmentInfo si)
 249                 {
 250                         return si.dir.FileExists(si.name + ".cfs");
 251                 }
 252
 253                 internal static bool HasSeparateNorms(SegmentInfo si)
 254                 {
 255                         System.String[] result = si.dir.List();
 256                         System.String pattern = si.name + ".f";
 257                         int patternLength = pattern.Length;
 258                         for (int i = 0; i < result.Length; i++)
 259                         {
 260                                 if (result[i].StartsWith(pattern) && System.Char.IsDigit(result[i][patternLength]))
 261                                         return true;
 262                         }
 263                         return false;
 264                 }
 265
 266                 protected internal override void  DoDelete(int docNum)
 267                 {
 268                         if (deletedDocs == null)
 269                                 deletedDocs = new BitVector(MaxDoc());
 270                         deletedDocsDirty = true;
 271                         undeleteAll = false;
 272                         deletedDocs.Set(docNum);
 273                 }
 274
 275                 protected internal override void  DoUndeleteAll()
 276                 {
 277                         deletedDocs = null;
 278                         deletedDocsDirty = false;
 279                         undeleteAll = true;
 280                 }
 281
 282                 internal virtual System.Collections.ArrayList Files()
 283                 {
 284                         System.Collections.ArrayList files = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(16));
 285                         System.String[] ext = new System.String[]{"cfs", "fnm", "fdx", "fdt", "tii", "tis", "frq", "prx", "del", "tvx", "tvd", "tvf", "tvp"};
 286
 287                         for (int i = 0; i < ext.Length; i++)
 288                         {
 289                                 System.String name = segment + "." + ext[i];
 290                                 if (Directory().FileExists(name))
 291                                         files.Add(name);
 292                         }
 293
 294                         for (int i = 0; i < fieldInfos.Size(); i++)
 295                         {
 296                                 FieldInfo fi = fieldInfos.FieldInfo(i);
 297                                 if (fi.isIndexed)
 298                 {
 299                     System.String name;
 300                     if (cfsReader == null)
 301                         name = segment + ".f" + i;
 302                     else
 303                         name = segment + ".s" + i;
 304                     if (Directory().FileExists(name))
 305                         files.Add(name);
 306                 }
 307             }
 308                         return files;
 309                 }
 310
 311                 public override TermEnum Terms()
 312                 {
 313                         return tis.Terms();
 314                 }
 315
 316                 public override TermEnum Terms(Term t)
 317                 {
 318                         return tis.Terms(t);
 319                 }
 320
 321                 public override Document Document(int n)
 322                 {
 323                         lock (this)
 324                         {
 325                                 if (IsDeleted(n))
 326                                         throw new System.ArgumentException("attempt to access a deleted document");
 327                                 return fieldsReader.Doc(n);
 328                         }
 329                 }
 330
 331                 public override bool IsDeleted(int n)
 332                 {
 333                         lock (this)
 334                         {
 335                                 return (deletedDocs != null && deletedDocs.Get(n));
 336                         }
 337                 }
 338
 339                 public override TermDocs TermDocs()
 340                 {
 341                         return new SegmentTermDocs(this);
 342                 }
 343
 344                 public override TermPositions TermPositions()
 345                 {
 346                         return new SegmentTermPositions(this);
 347                 }
 348
 349                 public override int DocFreq(Term t)
 350                 {
 351                         TermInfo ti = tis.Get(t);
 352                         if (ti != null)
 353                                 return ti.docFreq;
 354                         else
 355                                 return 0;
 356                 }
 357
 358                 public override int NumDocs()
 359                 {
 360                         int n = MaxDoc();
 361                         if (deletedDocs != null)
 362                                 n -= deletedDocs.Count();
 363                         return n;
 364                 }
 365
 366                 public override int MaxDoc()
 367                 {
 368                         return fieldsReader.Size();
 369                 }
 370
 371                 /// <seealso cref="IndexReader#GetFieldNames()">
 372                 /// </seealso>
 373         /// <deprecated>  Replaced by {@link #GetFieldNames (IndexReader.FieldOption fldOption)}
 374         /// </deprecated>
 375         public override System.Collections.ICollection GetFieldNames()
 376                 {
 377                         // maintain a unique set of Field names
 378                         System.Collections.Hashtable fieldSet = new System.Collections.Hashtable();
 379                         for (int i = 0; i < fieldInfos.Size(); i++)
 380                         {
 381                                 FieldInfo fi = fieldInfos.FieldInfo(i);
 382                                 fieldSet.Add(fi.name, fi.name);
 383                         }
 384                         return fieldSet;
 385                 }
 386
 387                 /// <seealso cref="IndexReader#GetFieldNames(boolean)">
 388                 /// </seealso>
 389         /// <deprecated>  Replaced by {@link #GetFieldNames (IndexReader.FieldOption fldOption)}
 390         /// </deprecated>
 391         public override System.Collections.ICollection GetFieldNames(bool indexed)
 392                 {
 393                         // maintain a unique set of Field names
 394                         System.Collections.Hashtable fieldSet = new System.Collections.Hashtable();
 395                         for (int i = 0; i < fieldInfos.Size(); i++)
 396                         {
 397                                 FieldInfo fi = fieldInfos.FieldInfo(i);
 398                                 if (fi.isIndexed == indexed)
 399                                         fieldSet.Add(fi.name, fi.name);
 400                         }
 401                         return fieldSet;
 402                 }
 403
 404         /// <seealso cref="tvSpec)">
 405         /// </seealso>
 406         /// <deprecated>  Replaced by {@link #GetFieldNames (IndexReader.FieldOption fldOption)}
 407         /// </deprecated>
 408         public override System.Collections.ICollection GetIndexedFieldNames(Field.TermVector tvSpec)
 409                 {
 410             bool storedTermVector;
 411             bool storePositionWithTermVector;
 412             bool storeOffsetWithTermVector;
 413
 414             if (tvSpec == Field.TermVector.NO)
 415             {
 416                 storedTermVector = false;
 417                 storePositionWithTermVector = false;
 418                 storeOffsetWithTermVector = false;
 419             }
 420             else if (tvSpec == Field.TermVector.YES)
 421             {
 422                 storedTermVector = true;
 423                 storePositionWithTermVector = false;
 424                 storeOffsetWithTermVector = false;
 425             }
 426             else if (tvSpec == Field.TermVector.WITH_POSITIONS)
 427             {
 428                 storedTermVector = true;
 429                 storePositionWithTermVector = true;
 430                 storeOffsetWithTermVector = false;
 431             }
 432             else if (tvSpec == Field.TermVector.WITH_OFFSETS)
 433             {
 434                 storedTermVector = true;
 435                 storePositionWithTermVector = false;
 436                 storeOffsetWithTermVector = true;
 437             }
 438             else if (tvSpec == Field.TermVector.WITH_POSITIONS_OFFSETS)
 439             {
 440                 storedTermVector = true;
 441                 storePositionWithTermVector = true;
 442                 storeOffsetWithTermVector = true;
 443             }
 444             else
 445             {
 446                 throw new System.ArgumentException("unknown termVector parameter " + tvSpec);
 447             }
 448
 449             // maintain a unique set of Field names
 450                         System.Collections.Hashtable fieldSet = new System.Collections.Hashtable();
 451                         for (int i = 0; i < fieldInfos.Size(); i++)
 452                         {
 453                                 FieldInfo fi = fieldInfos.FieldInfo(i);
 454                                 if (fi.isIndexed && fi.storeTermVector == storedTermVector && fi.storePositionWithTermVector == storePositionWithTermVector && fi.storeOffsetWithTermVector == storeOffsetWithTermVector)
 455                                 {
 456                                         fieldSet.Add(fi.name, fi.name);
 457                                 }
 458                         }
 459                         return fieldSet;
 460                 }
 461
 462         /// <seealso cref="fldOption)">
 463         /// </seealso>
 464         public override System.Collections.ICollection GetFieldNames(IndexReader.FieldOption fieldOption)
 465         {
 466                         System.Collections.Hashtable fieldSet = new System.Collections.Hashtable();
 467             for (int i = 0; i < fieldInfos.Size(); i++)
 468             {
 469                 FieldInfo fi = fieldInfos.FieldInfo(i);
 470                 if (fieldOption == IndexReader.FieldOption.ALL)
 471                 {
 472                     fieldSet.Add(fi.name, fi.name);
 473                 }
 474                 else if (!fi.isIndexed && fieldOption == IndexReader.FieldOption.UNINDEXED)
 475                 {
 476                     fieldSet.Add(fi.name, fi.name);
 477                 }
 478                 else if (fi.isIndexed && fieldOption == IndexReader.FieldOption.INDEXED)
 479                 {
 480                     fieldSet.Add(fi.name, fi.name);
 481                 }
 482                 else if (fi.isIndexed && fi.storeTermVector == false && fieldOption == IndexReader.FieldOption.INDEXED_NO_TERMVECTOR)
 483                 {
 484                     fieldSet.Add(fi.name, fi.name);
 485                 }
 486                 else if (fi.storeTermVector == true && fi.storePositionWithTermVector == false && fi.storeOffsetWithTermVector == false && fieldOption == IndexReader.FieldOption.TERMVECTOR)
 487                 {
 488                     fieldSet.Add(fi.name, fi.name);
 489                 }
 490                 else if (fi.isIndexed && fi.storeTermVector && fieldOption == IndexReader.FieldOption.INDEXED_WITH_TERMVECTOR)
 491                 {
 492                     fieldSet.Add(fi.name, fi.name);
 493                 }
 494                 else if (fi.storePositionWithTermVector && fi.storeOffsetWithTermVector == false && fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_POSITION)
 495                 {
 496                     fieldSet.Add(fi.name, fi.name);
 497                 }
 498                 else if (fi.storeOffsetWithTermVector && fi.storePositionWithTermVector == false && fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_OFFSET)
 499                 {
 500                     fieldSet.Add(fi.name, fi.name);
 501                 }
 502                 else if ((fi.storeOffsetWithTermVector && fi.storePositionWithTermVector) && fieldOption == IndexReader.FieldOption.TERMVECTOR_WITH_POSITION_OFFSET)
 503                 {
 504                     fieldSet.Add(fi.name, fi.name);
 505                 }
 506             }
 507             return fieldSet;
 508         }
 509
 510         /// <seealso cref="fldOption)">
 511         /// </seealso>
 512         public override byte[] Norms(System.String field)
 513                 {
 514                         lock (this)
 515                         {
 516                                 Norm norm = (Norm) norms[field];
 517                                 if (norm == null)
 518                                 // not an indexed Field
 519                                         return null;
 520                                 if (norm.bytes == null)
 521                                 {
 522                                         // value not yet read
 523                                         byte[] bytes = new byte[MaxDoc()];
 524                                         Norms(field, bytes, 0);
 525                                         norm.bytes = bytes; // cache it
 526                                 }
 527                                 return norm.bytes;
 528                         }
 529                 }
 530
 531                 protected internal override void  DoSetNorm(int doc, System.String field, byte value_Renamed)
 532                 {
 533                         Norm norm = (Norm) norms[field];
 534                         if (norm == null)
 535                         // not an indexed Field
 536                                 return ;
 537                         norm.dirty = true; // mark it dirty
 538                         normsDirty = true;
 539
 540                         Norms(field)[doc] = value_Renamed; // set the value
 541                 }
 542
 543                 /// <summary>Read norms into a pre-allocated array. </summary>
 544                 public override void  Norms(System.String field, byte[] bytes, int offset)
 545                 {
 546                         lock (this)
 547                         {
 548
 549                                 Norm norm = (Norm) norms[field];
 550                                 if (norm == null)
 551                                         return ; // use zeros in array
 552
 553                                 if (norm.bytes != null)
 554                                 {
 555                                         // can copy from cache
 556                                         Array.Copy(norm.bytes, 0, bytes, offset, MaxDoc());
 557                                         return ;
 558                                 }
 559
 560                                 IndexInput normStream = (IndexInput) norm.in_Renamed.Clone();
 561                                 try
 562                                 {
 563                                         // read from disk
 564                                         normStream.Seek(0);
 565                                         normStream.ReadBytes(bytes, offset, MaxDoc());
 566                                 }
 567                                 finally
 568                                 {
 569                                         normStream.Close();
 570                                 }
 571                         }
 572                 }
 573
 574                 private void  OpenNorms(Directory cfsDir)
 575                 {
 576                         for (int i = 0; i < fieldInfos.Size(); i++)
 577                         {
 578                                 FieldInfo fi = fieldInfos.FieldInfo(i);
 579                                 if (fi.isIndexed)
 580                                 {
 581                     // look first if there are separate norms in compound format
 582                                         System.String fileName = segment + ".s" + fi.number;
 583                                         Directory d = Directory();
 584                     if (!d.FileExists(fileName))
 585                     {
 586                         fileName = segment + ".f" + fi.number;
 587                         d = cfsDir;
 588                     }
 589                     norms[fi.name] = new Norm(this, d.OpenInput(fileName), fi.number);
 590                 }
 591                         }
 592                 }
 593
 594                 private void  CloseNorms()
 595                 {
 596                         lock (norms.SyncRoot)
 597                         {
 598                                 System.Collections.IEnumerator enumerator = norms.Values.GetEnumerator();
 599                                 while (enumerator.MoveNext())
 600                                 {
 601                                         Norm norm = (Norm) enumerator.Current;
 602                                         norm.in_Renamed.Close();
 603                                 }
 604                         }
 605                 }
 606
 607         /// <summary> Create a clone from the initial TermVectorsReader and store it in the ThreadLocal.</summary>
 608         /// <returns> TermVectorsReader
 609         /// </returns>
 610         private TermVectorsReader GetTermVectorsReader()
 611         {
 612             TermVectorsReader tvReader = (TermVectorsReader) System.Threading.Thread.GetData(termVectorsLocal);
 613             if (tvReader == null)
 614             {
 615                 tvReader = (TermVectorsReader) termVectorsReaderOrig.Clone();
 616                 System.Threading.Thread.SetData(termVectorsLocal, tvReader);
 617             }
 618             return tvReader;
 619         }
 620
 621         /// <summary>Return a term frequency vector for the specified document and Field. The
 622                 /// vector returned contains term numbers and frequencies for all terms in
 623                 /// the specified Field of this document, if the Field had storeTermVector
 624                 /// flag set.  If the flag was not set, the method returns null.
 625                 /// </summary>
 626         /// <throws>  IOException </throws>
 627         public override TermFreqVector GetTermFreqVector(int docNumber, System.String field)
 628                 {
 629                         // Check if this Field is invalid or has no stored term vector
 630                         FieldInfo fi = fieldInfos.FieldInfo(field);
 631                         if (fi == null || !fi.storeTermVector || termVectorsReaderOrig == null)
 632                                 return null;
 633
 634             TermVectorsReader termVectorsReader = GetTermVectorsReader();
 635             if (termVectorsReader == null)
 636                 return null;
 637
 638             return termVectorsReader.Get(docNumber, field);
 639                 }
 640
 641
 642                 /// <summary>Return an array of term frequency vectors for the specified document.
 643                 /// The array contains a vector for each vectorized Field in the document.
 644                 /// Each vector vector contains term numbers and frequencies for all terms
 645                 /// in a given vectorized Field.
 646                 /// If no such fields existed, the method returns null.
 647                 /// </summary>
 648         /// <throws>  IOException </throws>
 649         public override TermFreqVector[] GetTermFreqVectors(int docNumber)
 650                 {
 651             if (termVectorsReaderOrig == null)
 652                 return null;
 653
 654             TermVectorsReader termVectorsReader = GetTermVectorsReader();
 655             if (termVectorsReader == null)
 656                 return null;
 657
 658             return termVectorsReader.Get(docNumber);
 659         }
 660
 661                 static SegmentReader()
 662                 {
 663                         {
 664                                 try
 665                                 {
 666                                         System.String name = SupportClass.AppSettings.Get("Lucene.Net.SegmentReader.class", typeof(SegmentReader).FullName);
 667                                         IMPL = System.Type.GetType(name);
 668                                 }
 669                                 catch (System.Exception e)
 670                                 {
 671                                         throw new System.SystemException("cannot load SegmentReader class: " + e.ToString());
 672                                 }
 673                         }
 674                 }
 675         }
 676 }