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