beagled/Lucene.Net/Index/FieldsReader.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 Document = Lucene.Net.Documents.Document;
  19 using Field = Lucene.Net.Documents.Field;
  20 using Directory = Lucene.Net.Store.Directory;
  21 using IndexInput = Lucene.Net.Store.IndexInput;
  22
  23 namespace Lucene.Net.Index
  24 {
  25
  26         /// <summary> Class responsible for access to stored document fields.
  27         ///
  28         /// It uses &lt;segment&gt;.fdt and &lt;segment&gt;.fdx; files.
  29         ///
  30         /// </summary>
  31         /// <version>  $Id: FieldsReader.cs,v 1.4 2006/10/02 17:08:52 joeshaw Exp $
  32         /// </version>
  33         public sealed class FieldsReader
  34         {
  35                 private FieldInfos fieldInfos;
  36                 private IndexInput fieldsStream;
  37                 private IndexInput indexStream;
  38                 private int size;
  39
  40                 public /*internal*/ FieldsReader(Directory d, System.String segment, FieldInfos fn)
  41                 {
  42                         fieldInfos = fn;
  43
  44                         fieldsStream = d.OpenInput(segment + ".fdt");
  45                         indexStream = d.OpenInput(segment + ".fdx");
  46
  47                         size = (int) (indexStream.Length() / 8);
  48                 }
  49
  50                 public /*internal*/ void  Close()
  51                 {
  52                         fieldsStream.Close();
  53                         indexStream.Close();
  54                 }
  55
  56                 public /*internal*/ int Size()
  57                 {
  58                         return size;
  59                 }
  60
  61                 public /*internal*/ Document Doc(int n)
  62                 {
  63                         indexStream.Seek(n * 8L);
  64                         long position = indexStream.ReadLong();
  65                         fieldsStream.Seek(position);
  66
  67                         Document doc = new Document();
  68                         int numFields = fieldsStream.ReadVInt();
  69                         for (int i = 0; i < numFields; i++)
  70                         {
  71                                 int fieldNumber = fieldsStream.ReadVInt();
  72                                 FieldInfo fi = fieldInfos.FieldInfo(fieldNumber);
  73
  74                                 byte bits = fieldsStream.ReadByte();
  75
  76                                 bool compressed = (bits & FieldsWriter.FIELD_IS_COMPRESSED) != 0;
  77                                 bool tokenize = (bits & FieldsWriter.FIELD_IS_TOKENIZED) != 0;
  78
  79                                 if ((bits & FieldsWriter.FIELD_IS_BINARY) != 0)
  80                                 {
  81                                         byte[] b = new byte[fieldsStream.ReadVInt()];
  82                                         fieldsStream.ReadBytes(b, 0, b.Length);
  83                                         if (compressed)
  84                                                 doc.Add(new Field(fi.name, Uncompress(b), Field.Store.COMPRESS));
  85                                         else
  86                                                 doc.Add(new Field(fi.name, b, Field.Store.YES));
  87                                 }
  88                                 else
  89                                 {
  90                                         Field.Index index;
  91                                         Field.Store store = Field.Store.YES;
  92
  93                                         if (fi.isIndexed && tokenize)
  94                                                 index = Field.Index.TOKENIZED;
  95                                         else if (fi.isIndexed && !tokenize)
  96                                                 index = Field.Index.UN_TOKENIZED;
  97                                         else
  98                                                 index = Field.Index.NO;
  99
 100                                         Field.TermVector termVector = null;
 101                                         if (fi.storeTermVector)
 102                                         {
 103                                                 if (fi.storeOffsetWithTermVector)
 104                                                 {
 105                                                         if (fi.storePositionWithTermVector)
 106                                                         {
 107                                                                 termVector = Field.TermVector.WITH_POSITIONS_OFFSETS;
 108                                                         }
 109                                                         else
 110                                                         {
 111                                                                 termVector = Field.TermVector.WITH_OFFSETS;
 112                                                         }
 113                                                 }
 114                                                 else if (fi.storePositionWithTermVector)
 115                                                 {
 116                                                         termVector = Field.TermVector.WITH_POSITIONS;
 117                                                 }
 118                                                 else
 119                                                 {
 120                                                         termVector = Field.TermVector.YES;
 121                                                 }
 122                                         }
 123                                         else
 124                                         {
 125                                                 termVector = Field.TermVector.NO;
 126                                         }
 127
 128                                         if (compressed)
 129                                         {
 130                                                 store = Field.Store.COMPRESS;
 131                                                 byte[] b = new byte[fieldsStream.ReadVInt()];
 132                                                 fieldsStream.ReadBytes(b, 0, b.Length);
 133                                                 Field f = new Field(fi.name, System.Text.Encoding.GetEncoding("UTF-8").GetString(Uncompress(b)), store, index, termVector);
 134                                                 f.SetOmitNorms(fi.omitNorms);
 135                                                 doc.Add(f);
 136                                         }
 137                                         else
 138                                         {
 139                                                 Field f = new Field(fi.name, fieldsStream.ReadString(), store, index, termVector);
 140                                                 f.SetOmitNorms(fi.omitNorms);
 141                                                 doc.Add(f);
 142                                         }
 143                                 }
 144                         }
 145
 146                         return doc;
 147                 }
 148
 149                 private byte[] Uncompress(byte[] input)
 150                 {
 151             return SupportClass.CompressionSupport.Uncompress(input);
 152                 }
 153         }
 154 }