Java tutorial
/* * Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.io; /** * This class is an input stream filter that provides the added * functionality of keeping track of the current line number. * <p> * A line is a sequence of bytes ending with a carriage return * character ({@code '\u005Cr'}), a newline character * ({@code '\u005Cn'}), or a carriage return character followed * immediately by a linefeed character. In all three cases, the line * terminating character(s) are returned as a single newline character. * <p> * The line number begins at {@code 0}, and is incremented by * {@code 1} when a {@code read} returns a newline character. * * @author Arthur van Hoff * @see java.io.LineNumberReader * @since 1.0 * @deprecated This class incorrectly assumes that bytes adequately represent * characters. As of JDK 1.1, the preferred way to operate on * character streams is via the new character-stream classes, which * include a class for counting line numbers. */ @Deprecated public class LineNumberInputStream extends FilterInputStream { int pushBack = -1; int lineNumber; int markLineNumber; int markPushBack = -1; /** * Constructs a newline number input stream that reads its input * from the specified input stream. * * @param in the underlying input stream. */ public LineNumberInputStream(InputStream in) { super(in); } /** * Reads the next byte of data from this input stream. The value * byte is returned as an {@code int} in the range * {@code 0} to {@code 255}. If no byte is available * because the end of the stream has been reached, the value * {@code -1} is returned. This method blocks until input data * is available, the end of the stream is detected, or an exception * is thrown. * <p> * The {@code read} method of * {@code LineNumberInputStream} calls the {@code read} * method of the underlying input stream. It checks for carriage * returns and newline characters in the input, and modifies the * current line number as appropriate. A carriage-return character or * a carriage return followed by a newline character are both * converted into a single newline character. * * @return the next byte of data, or {@code -1} if the end of this * stream is reached. * @exception IOException if an I/O error occurs. * @see java.io.FilterInputStream#in * @see java.io.LineNumberInputStream#getLineNumber() */ @SuppressWarnings("fallthrough") public int read() throws IOException { int c = pushBack; if (c != -1) { pushBack = -1; } else { c = in.read(); } switch (c) { case '\r': pushBack = in.read(); if (pushBack == '\n') { pushBack = -1; } case '\n': lineNumber++; return '\n'; } return c; } /** * Reads up to {@code len} bytes of data from this input stream * into an array of bytes. This method blocks until some input is available. * <p> * The {@code read} method of * {@code LineNumberInputStream} repeatedly calls the * {@code read} method of zero arguments to fill in the byte array. * * @param b the buffer into which the data is read. * @param off the start offset of the data. * @param len the maximum number of bytes read. * @return the total number of bytes read into the buffer, or * {@code -1} if there is no more data because the end of * this stream has been reached. * @exception IOException if an I/O error occurs. * @see java.io.LineNumberInputStream#read() */ public int read(byte b[], int off, int len) throws IOException { if (b == null) { throw new NullPointerException(); } else if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) { throw new IndexOutOfBoundsException(); } else if (len == 0) { return 0; } int c = read(); if (c == -1) { return -1; } b[off] = (byte) c; int i = 1; try { for (; i < len; i++) { c = read(); if (c == -1) { break; } if (b != null) { b[off + i] = (byte) c; } } } catch (IOException ee) { } return i; } /** * Skips over and discards {@code n} bytes of data from this * input stream. The {@code skip} method may, for a variety of * reasons, end up skipping over some smaller number of bytes, * possibly {@code 0}. The actual number of bytes skipped is * returned. If {@code n} is negative, no bytes are skipped. * <p> * The {@code skip} method of {@code LineNumberInputStream} creates * a byte array and then repeatedly reads into it until * {@code n} bytes have been read or the end of the stream has * been reached. * * @param n the number of bytes to be skipped. * @return the actual number of bytes skipped. * @exception IOException if an I/O error occurs. * @see java.io.FilterInputStream#in */ public long skip(long n) throws IOException { int chunk = 2048; long remaining = n; byte data[]; int nr; if (n <= 0) { return 0; } data = new byte[chunk]; while (remaining > 0) { nr = read(data, 0, (int) Math.min(chunk, remaining)); if (nr < 0) { break; } remaining -= nr; } return n - remaining; } /** * Sets the line number to the specified argument. * * @param lineNumber the new line number. * @see #getLineNumber */ public void setLineNumber(int lineNumber) { this.lineNumber = lineNumber; } /** * Returns the current line number. * * @return the current line number. * @see #setLineNumber */ public int getLineNumber() { return lineNumber; } /** * Returns the number of bytes that can be read from this input * stream without blocking. * <p> * Note that if the underlying input stream is able to supply * <i>k</i> input characters without blocking, the * {@code LineNumberInputStream} can guarantee only to provide * <i>k</i>/2 characters without blocking, because the * <i>k</i> characters from the underlying input stream might * consist of <i>k</i>/2 pairs of {@code '\u005Cr'} and * {@code '\u005Cn'}, which are converted to just * <i>k</i>/2 {@code '\u005Cn'} characters. * * @return the number of bytes that can be read from this input stream * without blocking. * @exception IOException if an I/O error occurs. * @see java.io.FilterInputStream#in */ public int available() throws IOException { return (pushBack == -1) ? super.available() / 2 : super.available() / 2 + 1; } /** * Marks the current position in this input stream. A subsequent * call to the {@code reset} method repositions this stream at * the last marked position so that subsequent reads re-read the same bytes. * <p> * The {@code mark} method of * {@code LineNumberInputStream} remembers the current line * number in a private variable, and then calls the {@code mark} * method of the underlying input stream. * * @param readlimit the maximum limit of bytes that can be read before * the mark position becomes invalid. * @see java.io.FilterInputStream#in * @see java.io.LineNumberInputStream#reset() */ public void mark(int readlimit) { markLineNumber = lineNumber; markPushBack = pushBack; in.mark(readlimit); } /** * Repositions this stream to the position at the time the * {@code mark} method was last called on this input stream. * <p> * The {@code reset} method of * {@code LineNumberInputStream} resets the line number to be * the line number at the time the {@code mark} method was * called, and then calls the {@code reset} method of the * underlying input stream. * <p> * Stream marks are intended to be used in * situations where you need to read ahead a little to see what's in * the stream. Often this is most easily done by invoking some * general parser. If the stream is of the type handled by the * parser, it just chugs along happily. If the stream is not of * that type, the parser should toss an exception when it fails, * which, if it happens within readlimit bytes, allows the outer * code to reset the stream and try another parser. * * @exception IOException if an I/O error occurs. * @see java.io.FilterInputStream#in * @see java.io.LineNumberInputStream#mark(int) */ public void reset() throws IOException { lineNumber = markLineNumber; pushBack = markPushBack; in.reset(); } }