beagled/Lucene.Net/Index/FieldsWriter.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 IndexOutput = Lucene.Net.Store.IndexOutput;
  22
  23 namespace Lucene.Net.Index
  24 {
  25
  26         sealed class FieldsWriter
  27         {
  28                 internal const byte FIELD_IS_TOKENIZED = (byte) (0x1);
  29                 internal const byte FIELD_IS_BINARY = (byte) (0x2);
  30                 internal const byte FIELD_IS_COMPRESSED = (byte) (0x4);
  31
  32                 private FieldInfos fieldInfos;
  33
  34                 private IndexOutput fieldsStream;
  35
  36                 private IndexOutput indexStream;
  37
  38                 internal FieldsWriter(Directory d, System.String segment, FieldInfos fn)
  39                 {
  40                         fieldInfos = fn;
  41                         fieldsStream = d.CreateOutput(segment + ".fdt");
  42                         indexStream = d.CreateOutput(segment + ".fdx");
  43                 }
  44
  45                 internal void  Close()
  46                 {
  47                         fieldsStream.Close();
  48                         indexStream.Close();
  49                 }
  50
  51                 internal void  AddDocument(Document doc)
  52                 {
  53                         indexStream.WriteLong(fieldsStream.GetFilePointer());
  54
  55                         int storedCount = 0;
  56         foreach(Field field in doc.Fields())
  57         {
  58                                 if (field.IsStored())
  59                                         storedCount++;
  60                         }
  61                         fieldsStream.WriteVInt(storedCount);
  62
  63                         foreach(Field field in doc.Fields())
  64                         {
  65                                 if (field.IsStored())
  66                                 {
  67                                         fieldsStream.WriteVInt(fieldInfos.FieldNumber(field.Name()));
  68
  69                                         byte bits = 0;
  70                                         if (field.IsTokenized())
  71                                                 bits |= FieldsWriter.FIELD_IS_TOKENIZED;
  72                                         if (field.IsBinary())
  73                                                 bits |= FieldsWriter.FIELD_IS_BINARY;
  74                                         if (field.IsCompressed())
  75                                                 bits |= FieldsWriter.FIELD_IS_COMPRESSED;
  76
  77                                         fieldsStream.WriteByte(bits);
  78
  79                                         if (field.IsCompressed())
  80                                         {
  81                                                 // compression is enabled for the current field
  82                                                 byte[] data = null;
  83                                                 // check if it is a binary field
  84                                                 if (field.IsBinary())
  85                                                 {
  86                                                         data = Compress(field.BinaryValue());
  87                                                 }
  88                                                 else
  89                                                 {
  90                                                         data = Compress(System.Text.Encoding.GetEncoding("UTF-8").GetBytes(field.StringValue()));
  91                                                 }
  92                                                 int len = data.Length;
  93                                                 fieldsStream.WriteVInt(len);
  94                                                 fieldsStream.WriteBytes(data, len);
  95                                         }
  96                                         else
  97                                         {
  98                                                 // compression is disabled for the current field
  99                                                 if (field.IsBinary())
 100                                                 {
 101                                                         byte[] data = field.BinaryValue();
 102                                                         int len = data.Length;
 103                                                         fieldsStream.WriteVInt(len);
 104                                                         fieldsStream.WriteBytes(data, len);
 105                                                 }
 106                                                 else
 107                                                 {
 108                                                         fieldsStream.WriteString(field.StringValue());
 109                                                 }
 110                                         }
 111                                 }
 112                         }
 113                 }
 114
 115                 private byte[] Compress(byte[] input)
 116                 {
 117             return SupportClass.CompressionSupport.Compress(input);
 118                 }
 119         }
 120 }