beagled/Lucene.Net/Index/SegmentInfos.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 using IndexInput = Lucene.Net.Store.IndexInput;
  19 using IndexOutput = Lucene.Net.Store.IndexOutput;
  20 namespace Lucene.Net.Index
  21 {
  22
  23         [Serializable]
  24         sealed public class SegmentInfos : System.Collections.ArrayList
  25         {
  26
  27                 /// <summary>The file format version, a negative number. </summary>
  28                 /* Works since counter, the old 1st entry, is always >= 0 */
  29                 public const int FORMAT = - 1;
  30
  31                 public int counter = 0; // used to name new segments
  32                 private long version = 0; //counts how often the index has been changed by adding or deleting docs
  33
  34                 public SegmentInfo Info(int i)
  35                 {
  36                         return (SegmentInfo) this[i];
  37                 }
  38
  39                 public void  Read(Directory directory)
  40                 {
  41
  42                         IndexInput input = directory.OpenInput("segments");
  43                         try
  44                         {
  45                                 int format = input.ReadInt();
  46                                 if (format < 0)
  47                                 {
  48                                         // file contains explicit format info
  49                                         // check that it is a format we can understand
  50                                         if (format < FORMAT)
  51                                                 throw new System.IO.IOException("Unknown format version: " + format);
  52                                         version = input.ReadLong(); // read version
  53                                         counter = input.ReadInt(); // read counter
  54                                 }
  55                                 else
  56                                 {
  57                                         // file is in old format without explicit format info
  58                                         counter = format;
  59                                 }
  60
  61                                 for (int i = input.ReadInt(); i > 0; i--)
  62                                 {
  63                                         // read segmentInfos
  64                                         SegmentInfo si = new SegmentInfo(input.ReadString(), input.ReadInt(), directory);
  65                                         Add(si);
  66                                 }
  67
  68                                 if (format >= 0)
  69                                 {
  70                                         // in old format the version number may be at the end of the file
  71                                         if (input.GetFilePointer() >= input.Length())
  72                                                 version = 0;
  73                                         // old file format without version number
  74                                         else
  75                                                 version = input.ReadLong(); // read version
  76                                 }
  77                         }
  78                         finally
  79                         {
  80                                 input.Close();
  81                         }
  82                 }
  83
  84                 public void  Write(Directory directory)
  85                 {
  86                         IndexOutput output = directory.CreateOutput("segments.new");
  87                         try
  88                         {
  89                                 output.WriteInt(FORMAT); // write FORMAT
  90                                 output.WriteLong(++version); // every write changes the index
  91                                 output.WriteInt(counter); // write counter
  92                                 output.WriteInt(Count); // write infos
  93                                 for (int i = 0; i < Count; i++)
  94                                 {
  95                                         SegmentInfo si = Info(i);
  96                                         output.WriteString(si.name);
  97                                         output.WriteInt(si.docCount);
  98                                 }
  99                         }
 100                         finally
 101                         {
 102                                 output.Close();
 103                         }
 104
 105                         // install new segment info
 106                         directory.RenameFile("segments.new", "segments");
 107                 }
 108
 109                 /// <summary> version number when this SegmentInfos was generated.</summary>
 110                 public long GetVersion()
 111                 {
 112                         return version;
 113                 }
 114
 115                 /// <summary> Current version number from segments file.</summary>
 116                 public static long ReadCurrentVersion(Directory directory)
 117                 {
 118
 119                         IndexInput input = directory.OpenInput("segments");
 120                         int format = 0;
 121                         long version = 0;
 122                         try
 123                         {
 124                                 format = input.ReadInt();
 125                                 if (format < 0)
 126                                 {
 127                                         if (format < FORMAT)
 128                                                 throw new System.IO.IOException("Unknown format version: " + format);
 129                                         version = input.ReadLong(); // read version
 130                                 }
 131                         }
 132                         finally
 133                         {
 134                                 input.Close();
 135                         }
 136
 137                         if (format < 0)
 138                                 return version;
 139
 140                         // We cannot be sure about the format of the file.
 141                         // Therefore we have to read the whole file and cannot simply seek to the version entry.
 142
 143                         SegmentInfos sis = new SegmentInfos();
 144                         sis.Read(directory);
 145                         return sis.GetVersion();
 146                 }
 147         }
 148 }