beagled/Lucene.Net/QueryParser/FastCharStream.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 namespace Lucene.Net.QueryParsers
  18 {
  19
  20         /// <summary>An efficient implementation of JavaCC's CharStream interface.  <p>Note that
  21         /// this does not do line-number counting, but instead keeps track of the
  22         /// character position of the token in the input, as required by Lucene's {@link
  23         /// Lucene.Net.Analysis.Token} API.
  24         /// </summary>
  25         public sealed class FastCharStream : CharStream
  26         {
  27                 internal char[] buffer = null;
  28
  29                 internal int bufferLength = 0; // end of valid chars
  30                 internal int bufferPosition = 0; // next char to read
  31
  32                 internal int tokenStart = 0; // offset in buffer
  33                 internal int bufferStart = 0; // position in file of buffer
  34
  35                 internal System.IO.TextReader input; // source of chars
  36
  37                 /// <summary>Constructs from a Reader. </summary>
  38                 public FastCharStream(System.IO.TextReader r)
  39                 {
  40                         input = r;
  41                 }
  42
  43                 public char ReadChar()
  44                 {
  45                         if (bufferPosition >= bufferLength)
  46                                 Refill();
  47                         return buffer[bufferPosition++];
  48                 }
  49
  50                 private void  Refill()
  51                 {
  52                         int newPosition = bufferLength - tokenStart;
  53
  54                         if (tokenStart == 0)
  55                         {
  56                                 // token won't fit in buffer
  57                                 if (buffer == null)
  58                                 {
  59                                         // first time: alloc buffer
  60                                         buffer = new char[2048];
  61                                 }
  62                                 else if (bufferLength == buffer.Length)
  63                                 {
  64                                         // grow buffer
  65                                         char[] newBuffer = new char[buffer.Length * 2];
  66                                         Array.Copy(buffer, 0, newBuffer, 0, bufferLength);
  67                                         buffer = newBuffer;
  68                                 }
  69                         }
  70                         else
  71                         {
  72                                 // shift token to front
  73                                 Array.Copy(buffer, tokenStart, buffer, 0, newPosition);
  74                         }
  75
  76                         bufferLength = newPosition; // update state
  77                         bufferPosition = newPosition;
  78                         bufferStart += tokenStart;
  79                         tokenStart = 0;
  80
  81             int charsRead = 0;
  82
  83             try
  84             {
  85                 charsRead = input.Read(buffer, newPosition, buffer.Length - newPosition);
  86             }
  87             catch
  88             {
  89             }
  90
  91                         if (charsRead <= 0)
  92                                 throw new System.IO.IOException("read past eof");
  93                         else
  94                                 bufferLength += charsRead;
  95                 }
  96
  97                 public char BeginToken()
  98                 {
  99                         tokenStart = bufferPosition;
 100                         return ReadChar();
 101                 }
 102
 103                 public void  Backup(int amount)
 104                 {
 105                         bufferPosition -= amount;
 106                 }
 107
 108                 public System.String GetImage()
 109                 {
 110                         return new System.String(buffer, tokenStart, bufferPosition - tokenStart);
 111                 }
 112
 113                 public char[] GetSuffix(int len)
 114                 {
 115                         char[] value_Renamed = new char[len];
 116                         Array.Copy(buffer, bufferPosition - len, value_Renamed, 0, len);
 117                         return value_Renamed;
 118                 }
 119
 120                 public void  Done()
 121                 {
 122                         try
 123                         {
 124                                 input.Close();
 125                         }
 126                         catch (System.IO.IOException e)
 127                         {
 128                                 System.Console.Error.WriteLine("Caught: " + e + "; ignoring.");
 129                         }
 130                 }
 131
 132                 public int GetColumn()
 133                 {
 134                         return bufferStart + bufferPosition;
 135                 }
 136                 public int GetLine()
 137                 {
 138                         return 1;
 139                 }
 140                 public int GetEndColumn()
 141                 {
 142                         return bufferStart + bufferPosition;
 143                 }
 144                 public int GetEndLine()
 145                 {
 146                         return 1;
 147                 }
 148                 public int GetBeginColumn()
 149                 {
 150                         return bufferStart + tokenStart;
 151                 }
 152                 public int GetBeginLine()
 153                 {
 154                         return 1;
 155                 }
 156         }
 157 }