InputStream
* except that it counts line numbers, and canonicalizes newline
* characters. As data is read, whenever the byte sequences "\r",
* "\n", or "\r\n" are encountered, the running line count is
* incremeted by one. Additionally, the whatever line termination
* sequence was encountered will be converted to a "\n" byte. Note
* that this class numbers lines from 0. When the first line
* terminator is encountered, the line number is incremented to 1, and
* so on.
* * This class counts only line termination characters. If the last line * read from the stream does not end in a line termination sequence, it * will not be counted as a line. *
* Note that since this class operates as a filter on an underlying
* stream, it has the same mark/reset functionality as the underlying
* stream. The mark() and reset() methods
* in this class handle line numbers correctly. Calling
* reset() resets the line number to the point at which
* mark() was called if the subordinate stream supports
* that functionality.
*
* @deprecated This class is deprecated in favor if
* LineNumberReader because it operates on ASCII bytes
* instead of an encoded character stream. This class is for backward
* compatibility only and should not be used in new applications.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Warren Levy (warrenl@cygnus.com)
*/
public class LineNumberInputStream extends FilterInputStream
{
/** The current line number. */
private int lineNumber = 0;
/** The line number when the stream was marked. */
private int markLineNumber = 0;
/** Flag to indicate a '\r' was just read so that an immediately
* subsequent '\n' can be ignored. */
private boolean justReadReturnChar = false;
/**
* Create a new LineNumberInputStream that reads from the
* specified subordinate InputStream
*
* @param in The subordinate InputStream to read from
*/
public LineNumberInputStream(InputStream in)
{
super(in);
}
/**
* This method returns the number of bytes that can be read from the
* stream before the stream can block. This method is tricky
* because the subordinate InputStream might return
* only "\r\n" characters, which are replaced by a single "\n"
* character by the read() method of this class. So
* this method can only guarantee that in.available() /
* 2 bytes can actually be read before blocking. In
* practice, considerably more bytes might be read before blocking
*
* Note that the stream may not block if additional bytes beyond the count
* returned by this method are read.
*
* @return The number of bytes that can be read before blocking could occur
*
* @exception IOException If an error occurs
*/
public int available() throws IOException
{
// We can only guarantee half the characters that might be available
// without blocking because "\r\n" is treated as a single character.
return in.available() / 2;
}
/**
* This method returns the current line number
*
* @return The current line number
*/
public int getLineNumber()
{
return lineNumber;
}
/**
* This method marks a position in the input to which the stream can
* be "reset" byte calling the reset() method. The
* parameter readlimit is the number of bytes that can
* be read from the stream after setting the mark before the mark
* becomes invalid. For example, if mark() is called
* with a read limit of 10, then when 11 bytes of data are read from
* the stream before the reset() method is called, then
* the mark is invalid and the stream object instance is not
* required to remember the mark.
*
* In this class, this method will remember the current line number
* as well as the current position in the stream. When the
* reset() method is called, the line number will be
* restored to the saved line number in addition to the stream
* position.
*
* This method only works if the subordinate stream supports mark/reset * functionality. * * @param readlimit The number of bytes that can be read before the * mark becomes invalid */ public void mark(int readlimit) { in.mark(readlimit); markLineNumber = lineNumber; } /** * This method reads an unsigned byte from the input stream and returns it * as an int in the range of 0-255. This method will return -1 if the * end of the stream has been reached. *
* Note that if a line termination sequence is encountered (ie, "\r", * "\n", or "\r\n") then that line termination sequence is converted to * a single "\n" value which is returned from this method. This means * that it is possible this method reads two bytes from the subordinate * stream instead of just one. *
* Note that this method will block until a byte of data is available
* to be read.
*
* @return The byte read or -1 if end of stream
*
* @exception IOException If an error occurs
*/
public int read() throws IOException
{
// Treat "\r\n" as a single character. A '\r' may have been read by
// a previous call to read so we keep an internal flag to avoid having
// to read ahead.
int ch = in.read();
if (ch == '\n')
if (justReadReturnChar)
{
ch = in.read();
justReadReturnChar = false;
}
else
lineNumber++;
else if (ch == '\r')
{
ch = '\n';
justReadReturnChar = true;
lineNumber++;
}
else
justReadReturnChar = false;
return ch;
}
/**
* This method reads bytes from a stream and stores them into a caller
* supplied buffer. It starts storing data at index offset into
* the buffer and attemps to read len bytes. This method can
* return before reading the number of bytes requested. The actual number
* of bytes read is returned as an int. A -1 is returned to indicated the
* end of the stream.
*
* This method will block until some data can be read. *
* Note that if a line termination sequence is encountered (ie, "\r",
* "\n", or "\r\n") then that line termination sequence is converted to
* a single "\n" value which is stored in the buffer. Only a single
* byte is counted towards the number of bytes read in this case.
*
* @param buf The array into which the bytes read should be stored
* @param offset The offset into the array to start storing bytes
* @param len The requested number of bytes to read
*
* @return The actual number of bytes read, or -1 if end of stream
*
* @exception IOException If an error occurs.
*/
public int read(byte[] b, int off, int len) throws IOException
{
if (off < 0 || len < 0 || off + len > b.length)
throw new ArrayIndexOutOfBoundsException();
// This case always succeeds.
if (len == 0)
return 0;
// The simplest, though not necessarily the most time efficient thing
// to do is simply call read(void) len times. Since this is a deprecated
// class, that should be ok.
final int origOff = off;
while (len-- > 0)
{
int ch = read();
if (ch < 0)
break;
b[off++] = (byte) ch;
}
// This is safe since we already know that some bytes were
// actually requested.
return off == origOff ? -1 : off - origOff;
}
/**
* This method resets a stream to the point where the
* mark() method was called. Any bytes that were read
* after the mark point was set will be re-read during subsequent
* reads.
*
* In this class, this method will also restore the line number that was
* current when the mark() method was called.
*
* This method only works if the subordinate stream supports mark/reset * functionality. * * @exception IOException If an error occurs */ public void reset() throws IOException { in.reset(); lineNumber = markLineNumber; justReadReturnChar = false; } /** * This method sets the current line number to the specified value. * * @param lineNumber The new line number */ public void setLineNumber(int lineNumber) { this.lineNumber = lineNumber; } /** * This method skips up to the requested number of bytes in the * input stream. The actual number of bytes skipped is returned. If the * desired number of bytes to skip is negative, no bytes are skipped. * * @param n requested number of bytes to skip. * * @return The actual number of bytes skipped. * * @exception IOException If an error occurs. */ public long skip(long n) throws IOException { if (n <= 0) return 0L; final long origN = n; do { int ch = read(); if (ch < 0) break; if (ch == '\n' || ch == '\r') lineNumber++; } while (--n > 0); return origN - n; } }