beagled/Lucene.Net/Store/BufferedIndexInput.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
  19 namespace Lucene.Net.Store
  20 {
  21
  22         /// <summary>Base implementation class for buffered {@link IndexInput}. </summary>
  23         public abstract class BufferedIndexInput : IndexInput, System.ICloneable
  24         {
  25                 internal static readonly int BUFFER_SIZE;
  26
  27                 private byte[] buffer;
  28
  29                 private long bufferStart = 0; // position in file of buffer
  30                 private int bufferLength = 0; // end of valid bytes
  31                 private int bufferPosition = 0; // next byte to read
  32
  33                 public override byte ReadByte()
  34                 {
  35                         if (bufferPosition >= bufferLength)
  36                                 Refill();
  37                         return buffer[bufferPosition++];
  38                 }
  39
  40                 public override void  ReadBytes(byte[] b, int offset, int len)
  41                 {
  42                         if (len < BUFFER_SIZE)
  43                         {
  44                                 for (int i = 0; i < len; i++)
  45                                     // read byte-by-byte
  46                                         b[i + offset] = (byte) ReadByte();
  47                         }
  48                         else
  49                         {
  50                                 // read all-at-once
  51                                 long start = GetFilePointer();
  52                                 SeekInternal(start);
  53                                 ReadInternal(b, offset, len);
  54
  55                                 bufferStart = start + len; // adjust stream variables
  56                                 bufferPosition = 0;
  57                                 bufferLength = 0; // trigger refill() on read
  58                         }
  59                 }
  60
  61                 private void  Refill()
  62                 {
  63                         long start = bufferStart + bufferPosition;
  64                         long end = start + BUFFER_SIZE;
  65                         if (end > Length())
  66                             // don't read past EOF
  67                                 end = Length();
  68                         bufferLength = (int) (end - start);
  69                         if (bufferLength <= 0)
  70                                 throw new System.IO.IOException("read past EOF");
  71
  72                         if (buffer == null)
  73                                 buffer = new byte[BUFFER_SIZE]; // allocate buffer lazily
  74                         ReadInternal(buffer, 0, bufferLength);
  75
  76                         bufferStart = start;
  77                         bufferPosition = 0;
  78                 }
  79
  80                 /// <summary>Expert: implements buffer refill.  Reads bytes from the current position
  81                 /// in the input.
  82                 /// </summary>
  83                 /// <param name="b">the array to read bytes into
  84                 /// </param>
  85                 /// <param name="offset">the offset in the array to start storing bytes
  86                 /// </param>
  87                 /// <param name="length">the number of bytes to read
  88                 /// </param>
  89                 public abstract void  ReadInternal(byte[] b, int offset, int length);
  90
  91                 public override long GetFilePointer()
  92                 {
  93                         return bufferStart + bufferPosition;
  94                 }
  95
  96                 public override void  Seek(long pos)
  97                 {
  98                         if (pos >= bufferStart && pos < (bufferStart + bufferLength))
  99                                 bufferPosition = (int) (pos - bufferStart);
 100                             // seek within buffer
 101                         else
 102                         {
 103                                 bufferStart = pos;
 104                                 bufferPosition = 0;
 105                                 bufferLength = 0; // trigger refill() on read()
 106                                 SeekInternal(pos);
 107                         }
 108                 }
 109
 110                 /// <summary>Expert: implements seek.  Sets current position in this file, where the
 111                 /// next {@link #ReadInternal(byte[],int,int)} will occur.
 112                 /// </summary>
 113                 /// <seealso cref="ReadInternal(byte[],int,int)">
 114                 /// </seealso>
 115                 public abstract void  SeekInternal(long pos);
 116
 117                 public override System.Object Clone()
 118                 {
 119                         BufferedIndexInput clone = (BufferedIndexInput) base.Clone();
 120
 121                         if (buffer != null)
 122                         {
 123                                 clone.buffer = new byte[BUFFER_SIZE];
 124                                 Array.Copy(buffer, 0, clone.buffer, 0, bufferLength);
 125                         }
 126
 127                         return clone;
 128                 }
 129
 130         static BufferedIndexInput()
 131                 {
 132                         BUFFER_SIZE = BufferedIndexOutput.BUFFER_SIZE;
 133                 }
 134         }
 135 }