beagled/Lucene.Net/Store/RAMInputStream.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> A memory-resident {@link IndexInput} implementation.
  23         ///
  24         /// </summary>
  25         /// <version>  $Id: RAMInputStream.cs,v 1.3 2006/10/02 17:09:10 joeshaw Exp $
  26         /// </version>
  27
  28         class RAMInputStream : BufferedIndexInput, System.ICloneable
  29         {
  30                 private RAMFile file;
  31                 private int pointer = 0;
  32                 private long length;
  33
  34                 public RAMInputStream(RAMFile f)
  35                 {
  36                         file = f;
  37                         length = file.length;
  38                 }
  39
  40                 public override void  ReadInternal(byte[] dest, int destOffset, int len)
  41                 {
  42                         int remainder = len;
  43                         int start = pointer;
  44                         while (remainder != 0)
  45                         {
  46                                 int bufferNumber = start / BUFFER_SIZE;
  47                                 int bufferOffset = start % BUFFER_SIZE;
  48                                 int bytesInBuffer = BUFFER_SIZE - bufferOffset;
  49                                 int bytesToCopy = bytesInBuffer >= remainder?remainder:bytesInBuffer;
  50                                 byte[] buffer = (byte[]) file.buffers[bufferNumber];
  51                                 Array.Copy(buffer, bufferOffset, dest, destOffset, bytesToCopy);
  52                                 destOffset += bytesToCopy;
  53                                 start += bytesToCopy;
  54                                 remainder -= bytesToCopy;
  55                         }
  56                         pointer += len;
  57                 }
  58
  59                 public override void  Close()
  60                 {
  61                 }
  62
  63                 public override void  SeekInternal(long pos)
  64                 {
  65                         pointer = (int) pos;
  66                 }
  67
  68                 public override long Length()
  69                 {
  70                         return length;
  71                 }
  72
  73         /*
  74         // {{Aroush-1.9}} Do we need this Clone()?!
  75                 public override System.Object Clone()
  76                 {
  77             SegmentTermEnum clone = null;
  78             try
  79             {
  80                 clone = (SegmentTermEnum) base.MemberwiseClone();
  81             }
  82             catch (System.Exception)
  83             {
  84             }
  85
  86             return clone;
  87         }
  88         */
  89         }
  90 }