FileDocCategorySizeDatePackage
SimpleCharStream.javaAPI DocApache Lucene 1.4.39665Thu Sep 11 03:51:34 BST 2003org.apache.lucene.demo.html

SimpleCharStream

public class SimpleCharStream extends Object
An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).

Fields Summary
public static final boolean
staticFlag
int
bufsize
int
available
int
tokenBegin
public int
bufpos
protected int[]
bufline
protected int[]
bufcolumn
protected int
column
protected int
line
protected boolean
prevCharIsCR
protected boolean
prevCharIsLF
protected Reader
inputStream
protected char[]
buffer
protected int
maxNextCharInd
protected int
inBuf
Constructors Summary
public SimpleCharStream(Reader dstream, int startline, int startcolumn, int buffersize)

    inputStream = dstream;
    line = startline;
    column = startcolumn - 1;

    available = bufsize = buffersize;
    buffer = new char[buffersize];
    bufline = new int[buffersize];
    bufcolumn = new int[buffersize];
public SimpleCharStream(Reader dstream, int startline, int startcolumn)

     this(dstream, startline, startcolumn, 4096);
public SimpleCharStream(Reader dstream)

     this(dstream, 1, 1, 4096);
public SimpleCharStream(InputStream dstream, int startline, int startcolumn, int buffersize)

     this(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
public SimpleCharStream(InputStream dstream, int startline, int startcolumn)

     this(dstream, startline, startcolumn, 4096);
public SimpleCharStream(InputStream dstream)

     this(dstream, 1, 1, 4096);
Methods Summary
public charBeginToken()

     tokenBegin = -1;
     char c = readChar();
     tokenBegin = bufpos;

     return c;
public voidDone()

     buffer = null;
     bufline = null;
     bufcolumn = null;
protected voidExpandBuff(boolean wrapAround)


     
  
     char[] newbuffer = new char[bufsize + 2048];
     int newbufline[] = new int[bufsize + 2048];
     int newbufcolumn[] = new int[bufsize + 2048];

     try
     {
        if (wrapAround)
        {
           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
           System.arraycopy(buffer, 0, newbuffer,
                                             bufsize - tokenBegin, bufpos);
           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
           System.arraycopy(bufline, 0, newbufline, bufsize - tokenBegin, bufpos);
           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
           System.arraycopy(bufcolumn, 0, newbufcolumn, bufsize - tokenBegin, bufpos);
           bufcolumn = newbufcolumn;

           maxNextCharInd = (bufpos += (bufsize - tokenBegin));
        }
        else
        {
           System.arraycopy(buffer, tokenBegin, newbuffer, 0, bufsize - tokenBegin);
           buffer = newbuffer;

           System.arraycopy(bufline, tokenBegin, newbufline, 0, bufsize - tokenBegin);
           bufline = newbufline;

           System.arraycopy(bufcolumn, tokenBegin, newbufcolumn, 0, bufsize - tokenBegin);
           bufcolumn = newbufcolumn;

           maxNextCharInd = (bufpos -= tokenBegin);
        }
     }
     catch (Throwable t)
     {
        throw new Error(t.getMessage());
     }


     bufsize += 2048;
     available = bufsize;
     tokenBegin = 0;
protected voidFillBuff()

     if (maxNextCharInd == available)
     {
        if (available == bufsize)
        {
           if (tokenBegin > 2048)
           {
              bufpos = maxNextCharInd = 0;
              available = tokenBegin;
           }
           else if (tokenBegin < 0)
              bufpos = maxNextCharInd = 0;
           else
              ExpandBuff(false);
        }
        else if (available > tokenBegin)
           available = bufsize;
        else if ((tokenBegin - available) < 2048)
           ExpandBuff(true);
        else
           available = tokenBegin;
     }

     int i;
     try {
        if ((i = inputStream.read(buffer, maxNextCharInd,
                                    available - maxNextCharInd)) == -1)
        {
           inputStream.close();
           throw new java.io.IOException();
        }
        else
           maxNextCharInd += i;
        return;
     }
     catch(java.io.IOException e) {
        --bufpos;
        backup(0);
        if (tokenBegin == -1)
           tokenBegin = bufpos;
        throw e;
     }
public java.lang.StringGetImage()

     if (bufpos >= tokenBegin)
        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);
     else
        return new String(buffer, tokenBegin, bufsize - tokenBegin) +
                              new String(buffer, 0, bufpos + 1);
public char[]GetSuffix(int len)

     char[] ret = new char[len];

     if ((bufpos + 1) >= len)
        System.arraycopy(buffer, bufpos - len + 1, ret, 0, len);
     else
     {
        System.arraycopy(buffer, bufsize - (len - bufpos - 1), ret, 0,
                                                          len - bufpos - 1);
        System.arraycopy(buffer, 0, ret, len - bufpos - 1, bufpos + 1);
     }

     return ret;
public voidReInit(java.io.Reader dstream, int startline, int startcolumn, int buffersize)

    inputStream = dstream;
    line = startline;
    column = startcolumn - 1;

    if (buffer == null || buffersize != buffer.length)
    {
      available = bufsize = buffersize;
      buffer = new char[buffersize];
      bufline = new int[buffersize];
      bufcolumn = new int[buffersize];
    }
    prevCharIsLF = prevCharIsCR = false;
    tokenBegin = inBuf = maxNextCharInd = 0;
    bufpos = -1;
public voidReInit(java.io.Reader dstream, int startline, int startcolumn)

     ReInit(dstream, startline, startcolumn, 4096);
public voidReInit(java.io.Reader dstream)

     ReInit(dstream, 1, 1, 4096);
public voidReInit(java.io.InputStream dstream, int startline, int startcolumn, int buffersize)

     ReInit(new java.io.InputStreamReader(dstream), startline, startcolumn, 4096);
public voidReInit(java.io.InputStream dstream)

     ReInit(dstream, 1, 1, 4096);
public voidReInit(java.io.InputStream dstream, int startline, int startcolumn)

     ReInit(dstream, startline, startcolumn, 4096);
protected voidUpdateLineColumn(char c)

     column++;

     if (prevCharIsLF)
     {
        prevCharIsLF = false;
        line += (column = 1);
     }
     else if (prevCharIsCR)
     {
        prevCharIsCR = false;
        if (c == '\n")
        {
           prevCharIsLF = true;
        }
        else
           line += (column = 1);
     }

     switch (c)
     {
        case '\r" :
           prevCharIsCR = true;
           break;
        case '\n" :
           prevCharIsLF = true;
           break;
        case '\t" :
           column--;
           column += (8 - (column & 07));
           break;
        default :
           break;
     }

     bufline[bufpos] = line;
     bufcolumn[bufpos] = column;
public voidadjustBeginLineColumn(int newLine, int newCol)
Method to adjust line and column numbers for the start of a token.

     int start = tokenBegin;
     int len;

     if (bufpos >= tokenBegin)
     {
        len = bufpos - tokenBegin + inBuf + 1;
     }
     else
     {
        len = bufsize - tokenBegin + bufpos + 1 + inBuf;
     }

     int i = 0, j = 0, k = 0;
     int nextColDiff = 0, columnDiff = 0;

     while (i < len &&
            bufline[j = start % bufsize] == bufline[k = ++start % bufsize])
     {
        bufline[j] = newLine;
        nextColDiff = columnDiff + bufcolumn[k] - bufcolumn[j];
        bufcolumn[j] = newCol + columnDiff;
        columnDiff = nextColDiff;
        i++;
     } 

     if (i < len)
     {
        bufline[j] = newLine++;
        bufcolumn[j] = newCol + columnDiff;

        while (i++ < len)
        {
           if (bufline[j = start % bufsize] != bufline[++start % bufsize])
              bufline[j] = newLine++;
           else
              bufline[j] = newLine;
        }
     }

     line = bufline[j];
     column = bufcolumn[j];
public voidbackup(int amount)


    inBuf += amount;
    if ((bufpos -= amount) < 0)
       bufpos += bufsize;
public intgetBeginColumn()

     return bufcolumn[tokenBegin];
public intgetBeginLine()

     return bufline[tokenBegin];
public intgetColumn()

deprecated
see
#getEndColumn

     return bufcolumn[bufpos];
public intgetEndColumn()

     return bufcolumn[bufpos];
public intgetEndLine()

     return bufline[bufpos];
public intgetLine()

deprecated
see
#getEndLine

     return bufline[bufpos];
public charreadChar()

     if (inBuf > 0)
     {
        --inBuf;

        if (++bufpos == bufsize)
           bufpos = 0;

        return buffer[bufpos];
     }

     if (++bufpos >= maxNextCharInd)
        FillBuff();

     char c = buffer[bufpos];

     UpdateLineColumn(c);
     return (c);